From dda357657e3104e1dcc59ad93bf99a0c3a2c3a6b Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 09:34:54 +0300
Subject: [PATCH 01/38] docs(audits): add Bailsec Core report for v3.2.1

Covers commit 0ce59af across the parallelizer and tokens repositories.
---
 ...- Parallel Protocol - Core - 1st Report.pdf | Bin 0 -> 667777 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 docs/audits/v3.2.1/Bailsec - Parallel Protocol - Core - 1st Report.pdf

diff --git a/docs/audits/v3.2.1/Bailsec - Parallel Protocol - Core - 1st Report.pdf b/docs/audits/v3.2.1/Bailsec - Parallel Protocol - Core - 1st Report.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..239fd57dea7502915a39d55950d8ad25bfa0a7cb
GIT binary patch
literal 667777
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%0Aa(tFLeNBRC1YU77`^>fyLWal$(rhat9+j
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
Q10x_i;*pTh(9z`ie<+ZOO8@`>

literal 0
HcmV?d00001


From 9c4d48b0573c6c7beb74ce8ece4c9e8497ffffd8 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 09:34:54 +0300
Subject: [PATCH 02/38] fix(harvester): restrict harvest to trusted callers

harvest forwards caller-supplied router calldata and refreshes the
collateral oracle, so it cannot be exposed to arbitrary callers. This
aligns GenericHarvester with MultiBlockHarvester, which already gates
both of its entry points.

Closes Bailsec Core Issue_04, Issue_05 and Issue_07.
---
 contracts/helpers/GenericHarvester.sol | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/contracts/helpers/GenericHarvester.sol b/contracts/helpers/GenericHarvester.sol
index 3b31873..cf2efcb 100644
--- a/contracts/helpers/GenericHarvester.sol
+++ b/contracts/helpers/GenericHarvester.sol
@@ -25,7 +25,7 @@ enum SwapType {
 /// @title GenericHarvester
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
-/// @dev Generic contract for anyone to permissionlessly adjust the reserves of Angle Parallelizer
+/// @dev Generic contract for trusted callers to adjust the reserves of Angle Parallelizer
 /// @dev This contract is an authorized fork of Angle's GenericHarvester contract:
 /// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol
 contract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper {
@@ -98,7 +98,9 @@ contract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper
   /// `yieldBearingAsset` to the target exposure
   /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,
   /// it is used to lower the amount of the asset to harvest for example to have a lower slippage
-  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual {
+  /// @dev Restricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the
+  /// collateral oracle, neither of which can be safely exposed to arbitrary callers
+  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual onlyTrusted {
     if (scale > 1e9) revert InvalidParam();
     updateLimitExposuresYieldAsset(yieldBearingAsset);
     YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];

From a5fccc20b62c6abe51e74ef0fe3437cfe9e3e62a Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 09:34:54 +0300
Subject: [PATCH 03/38] fix(oracle): bound and log the MAX target ratchet

updateOracle raised the stored target to the current spot with no bound
on the increase, and emitted nothing, so a transient upward print could
be locked in permanently and left no trace in the logs.

A single update is now capped at MAX_ORACLE_RATCHET_STEP and emits
OracleTargetUpdated. Failing to ratchet is the conservative direction:
readMint clamps at the lower of spot and target, and readBurn cannot
raise a stale target above its stored value.

Part of Bailsec Core Issue_04.
---
 .../parallelizer/libraries/LibOracle.sol      | 19 +++++------
 contracts/utils/Constants.sol                 |  2 ++
 tests/fuzz/Oracle.t.sol                       | 34 +++++++++++++++++--
 3 files changed, 43 insertions(+), 12 deletions(-)

diff --git a/contracts/parallelizer/libraries/LibOracle.sol b/contracts/parallelizer/libraries/LibOracle.sol
index c0a84a7..54431f8 100644
--- a/contracts/parallelizer/libraries/LibOracle.sol
+++ b/contracts/parallelizer/libraries/LibOracle.sol
@@ -17,6 +17,9 @@ import "../Storage.sol";
 /// @dev This library is an authorized fork of Angle's `LibOracle` library
 /// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol
 library LibOracle {
+  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`
+  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);
+
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ACTIONS SPECIFIC ORACLES
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
@@ -254,17 +257,13 @@ library LibOracle {
     uint256 oracleValue = read(oracleType, BASE_18, oracleData);
 
     uint256 maxValue = abi.decode(targetData, (uint256));
-    if (oracleValue > maxValue) {
-      ts.collaterals[collateral].oracleConfig = abi.encode(
-        oracleType,
-        targetType,
-        oracleData,
-        // There are no checks whether the value increased or not
-        abi.encode(oracleValue),
-        hyperparameters
-      );
-    } else {
+    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single
+    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`
+    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {
       revert OracleUpdateFailed();
     }
+    ts.collaterals[collateral].oracleConfig =
+      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);
+    emit OracleTargetUpdated(collateral, maxValue, oracleValue);
   }
 }
diff --git a/contracts/utils/Constants.sol b/contracts/utils/Constants.sol
index d78bc0d..9ad8d55 100644
--- a/contracts/utils/Constants.sol
+++ b/contracts/utils/Constants.sol
@@ -40,6 +40,8 @@ uint256 constant MAX_MINT_FEE = BASE_12 - 1;
 uint256 constant MAX_PAYEES = 10;
 uint256 constant SECONDS_PER_YEAR = 365 days;
 uint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;
+/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price
+uint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;
 
 /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                      REENTRANT                                                      
diff --git a/tests/fuzz/Oracle.t.sol b/tests/fuzz/Oracle.t.sol
index d2c929e..a2f7505 100644
--- a/tests/fuzz/Oracle.t.sol
+++ b/tests/fuzz/Oracle.t.sol
@@ -717,6 +717,30 @@ contract OracleTest is Fixture, FunctionUtils {
     parallelizer.updateOracle(collateral);
   }
 
+  function test_revertWhen_updateOracle_AboveRatchetStep() public {
+    vm.prank(governor);
+    parallelizer.toggleTrusted(alice, Storage.TrustedType.Seller);
+
+    address collateral = _collaterals[0];
+    (Storage.OracleReadType readType,, bytes memory data,,) = parallelizer.getOracle(collateral);
+    (uint256 oracleValue,,,,) = parallelizer.getOracleValues(collateral);
+
+    vm.prank(governor);
+    parallelizer.setOracle(
+      collateral,
+      abi.encode(readType, Storage.OracleReadType.MAX, data, abi.encode(oracleValue), abi.encode(uint128(0), uint128(0)))
+    );
+
+    (, int256 currentValue,,,) = _oracles[0].latestRoundData();
+    // One wei above the largest increase a single ratchet may apply
+    uint256 aboveCap = (uint256(currentValue) * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) / BASE_18 + 1;
+    MockChainlinkOracle(address(_oracles[0])).setLatestAnswer(int256(aboveCap));
+
+    vm.prank(alice);
+    vm.expectRevert(Errors.OracleUpdateFailed.selector);
+    parallelizer.updateOracle(collateral);
+  }
+
   function testFuzz_updateOracle_Success(uint256 updateOracleValue, uint32 heartbeat) public {
     vm.prank(governor);
     parallelizer.toggleTrusted(alice, Storage.TrustedType.Seller);
@@ -743,8 +767,14 @@ contract OracleTest is Fixture, FunctionUtils {
     uint256 newOracleValue;
     {
       (, int256 oracleValueTmp,,,) = _oracles[indexCollat].latestRoundData();
-      updateOracleValue = bound(updateOracleValue, uint256(oracleValueTmp) + 1, _maxOracleValue);
-      if (updateOracleValue > _maxOracleValue) return;
+      uint256 currentValue = uint256(oracleValueTmp);
+      // A single ratchet cannot lift the target by more than `MAX_ORACLE_RATCHET_STEP`
+      uint256 upperBound = (currentValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) / BASE_18;
+      if (upperBound > _maxOracleValue) upperBound = _maxOracleValue;
+      uint256 lowerBound = currentValue + 1;
+      if (lowerBound < _minOracleValue * 10) lowerBound = _minOracleValue * 10;
+      if (lowerBound > upperBound) return;
+      updateOracleValue = bound(updateOracleValue, lowerBound, upperBound);
 
       uint256[3] memory latestOracleValue = [updateOracleValue, BASE_8, BASE_8];
       latestOracleValue = _updateOracleValues(latestOracleValue);

From dda91448409288447d739aea890ca9d66099ff27 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 10:12:42 +0300
Subject: [PATCH 04/38] fix(harvester): make setMaxSlippage write the live
 limit

setMaxSlippage wrote to maxTokenSlippage, a mapping no harvest path
reads: every live check uses yieldBearingData[asset].maxSlippage. A
governance tightening therefore appeared to succeed on chain while
leaving the effective limit untouched.

The setter now writes the parameter the harvests read, the dead mapping
is removed, and the bound matches setYieldBearingAssetData: 1e9 means
zero slippage protection and is rejected.

Closes Bailsec Core Issue_03.
---
 contracts/helpers/BaseHarvester.sol |  6 ++--
 tests/units/Harvester.t.sol         | 53 +++++++++++++++++++++++++++++
 2 files changed, 55 insertions(+), 4 deletions(-)
 create mode 100644 tests/units/Harvester.t.sol

diff --git a/contracts/helpers/BaseHarvester.sol b/contracts/helpers/BaseHarvester.sol
index 4f6fc9a..5b618a7 100644
--- a/contracts/helpers/BaseHarvester.sol
+++ b/contracts/helpers/BaseHarvester.sol
@@ -67,8 +67,6 @@ abstract contract BaseHarvester is IHarvester, AccessManaged {
   IParallelizer public immutable parallelizer;
   /// @notice TokenP handled by the `parallelizer` of interest
   ITokenP public immutable tokenP;
-  /// @notice Max slippage when dealing with the Parallelizer
-  mapping(address => uint96) public maxTokenSlippage;
   /// @notice Data associated to a yield bearing asset
   mapping(address => YieldBearingParams) public yieldBearingData;
   /// @notice trusted addresses that can update target exposure and do others non critical operations
@@ -283,8 +281,8 @@ abstract contract BaseHarvester is IHarvester, AccessManaged {
   }
 
   function _setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) internal virtual {
-    if (newMaxSlippage > 1e9) revert InvalidParam();
-    maxTokenSlippage[yieldBearingAsset] = newMaxSlippage;
+    if (newMaxSlippage >= 1e9) revert InvalidParam();
+    yieldBearingData[yieldBearingAsset].maxSlippage = newMaxSlippage;
   }
 
   function _scaleAmountBasedOnDecimals(
diff --git a/tests/units/Harvester.t.sol b/tests/units/Harvester.t.sol
new file mode 100644
index 0000000..5c3aa6d
--- /dev/null
+++ b/tests/units/Harvester.t.sol
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity 0.8.28;
+
+import { MultiBlockHarvester } from "contracts/helpers/MultiBlockHarvester.sol";
+import { IParallelizer } from "contracts/interfaces/IParallelizer.sol";
+import "contracts/utils/Constants.sol";
+import "contracts/utils/Errors.sol" as Errors;
+
+import { Fixture } from "../Fixture.sol";
+
+contract Test_Harvester_MaxSlippage is Fixture {
+  MultiBlockHarvester internal harvester;
+
+  address internal yieldBearingAsset;
+
+  function setUp() public override {
+    super.setUp();
+
+    yieldBearingAsset = address(eurY);
+    harvester = new MultiBlockHarvester(address(accessManager), tokenP, IParallelizer(address(parallelizer)));
+
+    vm.startPrank(governor);
+    accessManager.setTargetFunctionRole(
+      address(harvester), getGuardianBaseHarvesterSelectorAccess(), GUARDIAN_ROLE
+    );
+    accessManager.grantRole(GUARDIAN_ROLE, guardian, 0);
+    vm.stopPrank();
+
+    vm.prank(guardian);
+    harvester.setYieldBearingAssetData(yieldBearingAsset, address(eurA), 5e8, 1e8, 9e8, 1, 5e7);
+  }
+
+  function test_SetMaxSlippage_UpdatesTheLiveLimit() public {
+    vm.prank(guardian);
+    harvester.setMaxSlippage(yieldBearingAsset, 1e7);
+
+    (,,,,, uint96 maxSlippage) = harvester.yieldBearingData(yieldBearingAsset);
+    assertEq(maxSlippage, 1e7);
+  }
+
+  function test_RevertWhen_SetMaxSlippageIsFullSlippage() public {
+    vm.prank(guardian);
+    vm.expectRevert(Errors.InvalidParam.selector);
+    harvester.setMaxSlippage(yieldBearingAsset, 1e9);
+  }
+
+  function test_RevertWhen_SetMaxSlippageNotGuardian() public {
+    vm.prank(alice);
+    vm.expectRevert(abi.encodeWithSelector(Errors.AccessManagedUnauthorized.selector, alice));
+    harvester.setMaxSlippage(yieldBearingAsset, 1e7);
+  }
+}

From e744bdf89224226805a134ab011bf3ae783bcbfc Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 10:22:18 +0300
Subject: [PATCH 05/38] fix(harvester): reject partial router fills and credit
 positive settlement

Two defects in onFlashLoan, both already carried by the unmerged
rebalancer work and ported here so the audit remediation is complete on
its own.

The router was assumed to consume the full declared input while only the
output balance was checked. A partial fill left both the unspent input
and its standing allowance on the contract, outside the Parallelizer's
accounting. The input balance is now compared across the swap.

Settlement was also asymmetric: a shortfall was charged to the initiating
caller while a surplus stayed as an unattributed contract balance the
caller could not withdraw. The positive branch now credits the caller.

Closes Bailsec Core Issue_07 and Issue_08.
---
 contracts/helpers/GenericHarvester.sol | 11 ++++++++++-
 contracts/utils/Errors.sol             |  1 +
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/contracts/helpers/GenericHarvester.sol b/contracts/helpers/GenericHarvester.sol
index cf2efcb..a46f909 100644
--- a/contracts/helpers/GenericHarvester.sol
+++ b/contracts/helpers/GenericHarvester.sol
@@ -155,17 +155,26 @@ contract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper
         tokenOut = asset;
       }
     }
+    uint256 tokenInBalanceBefore = IERC20(tokenIn).balanceOf(address(this));
+
     uint256 amountOut =
       parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);
 
-    // Swap to tokenIn
+    // Swap to tokenOut
     amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);
 
+    // A partial fill would leave both the unspent input and its router allowance on this contract
+    if (IERC20(tokenIn).balanceOf(address(this)) > tokenInBalanceBefore) {
+      revert RouterDidNotConsumeAllTokens();
+    }
+
     _adjustAllowance(tokenOut, address(parallelizer), amountOut);
     uint256 amountStableOut =
       parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);
     if (amount > amountStableOut) {
       budget[sender] -= amount - amountStableOut; // Will revert if not enough funds
+    } else if (amountStableOut > amount) {
+      budget[sender] += amountStableOut - amount;
     }
     return CALLBACK_SUCCESS;
   }
diff --git a/contracts/utils/Errors.sol b/contracts/utils/Errors.sol
index 6ee3525..39b1db1 100644
--- a/contracts/utils/Errors.sol
+++ b/contracts/utils/Errors.sol
@@ -55,6 +55,7 @@ error ZeroAddress();
 error ZeroAmount();
 error ZeroSurplusAmount();
 error SwapError();
+error RouterDidNotConsumeAllTokens();
 error SlippageTooHigh();
 error InsufficientFunds();
 error Undercollateralized();

From fc99cdb56f37c333000a331622a129f64464b4ed Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 10:42:34 +0300
Subject: [PATCH 06/38] refactor(rebalancer): rename Harvester to Rebalancer

The contracts adjust the Parallelizer's exposure between a yield bearing
asset and its underlying, they do not collect yield, so Rebalancer is the
accurate name. It also aligns this repository with the contracts already
deployed under that name on Base and Avalanche.

Renamed: BaseHarvester, GenericHarvester and MultiBlockHarvester, along
with their deploy scripts, configuration keys and registry entries. The
IHarvester interface and the legacy ContractType.Harvester entry keep
their names so registry ordinals are unchanged, matching the deployed
contracts. Existing deployment records are left untouched: they document
what was deployed under the old name.
---
 README.md                                     | 10 +++----
 .../{BaseHarvester.sol => BaseRebalancer.sol} | 10 +++----
 ...ricHarvester.sol => GenericRebalancer.sol} | 12 ++++----
 ...Harvester.sol => MultiBlockRebalancer.sol} | 12 ++++----
 deploy/config/avalanche/config.json           |  2 +-
 deploy/config/base/config.json                |  2 +-
 deploy/config/hyperevm/config.json            |  2 +-
 deploy/config/mainnet/config.json             |  2 +-
 deploy/config/sonic/config.json               |  2 +-
 ...nericHarvester.ts => GenericRebalancer.ts} | 16 +++++------
 deploy/utils/types.ts                         |  6 ++--
 ...BaseHarvester.d.ts => BaseRebalancer.d.ts} | 23 ++-------------
 .../{BaseHarvester.js => BaseRebalancer.js}   | 21 +-------------
 generated/abis/DiamondInitializer.d.ts        | 25 +++++++++++++++++
 generated/abis/DiamondInitializer.js          | 25 +++++++++++++++++
 ...cHarvester.d.ts => GenericRebalancer.d.ts} | 28 +++++--------------
 ...nericHarvester.js => GenericRebalancer.js} | 26 ++++-------------
 generated/abis/LibOracle.d.ts                 | 28 ++++++++++++++++++-
 generated/abis/LibOracle.js                   | 28 ++++++++++++++++++-
 ...rvester.d.ts => MultiBlockRebalancer.d.ts} | 23 ++-------------
 ...ckHarvester.js => MultiBlockRebalancer.js} | 21 +-------------
 generated/abis/SettersGovernor.d.ts           | 25 +++++++++++++++++
 generated/abis/SettersGovernor.js             | 25 +++++++++++++++++
 generated/abis/index.d.ts                     |  7 +++--
 generated/abis/index.js                       |  7 +++--
 libs/helpers/CommonUtils.sol                  |  8 +++---
 libs/helpers/Constants.sol                    |  4 +--
 libs/helpers/registry/registry.json           |  4 +--
 scripts/SetGenericHarvesterRoles.s.sol        | 26 -----------------
 scripts/SetGenericRebalancerRoles.s.sol       | 26 +++++++++++++++++
 ...l => SetupGenericRebalancerExposure.s.sol} | 10 +++----
 .../{Harvester.t.sol => Rebalancer.t.sol}     | 20 ++++++-------
 tests/utils/ConfigAccessManager.sol           | 28 +++++++++----------
 33 files changed, 282 insertions(+), 232 deletions(-)
 rename contracts/helpers/{BaseHarvester.sol => BaseRebalancer.sol} (97%)
 rename contracts/helpers/{GenericHarvester.sol => GenericRebalancer.sol} (96%)
 rename contracts/helpers/{MultiBlockHarvester.sol => MultiBlockRebalancer.sol} (96%)
 rename deploy/scripts/{GenericHarvester.ts => GenericRebalancer.ts} (71%)
 rename generated/abis/{BaseHarvester.d.ts => BaseRebalancer.d.ts} (94%)
 rename generated/abis/{BaseHarvester.js => BaseRebalancer.js} (95%)
 rename generated/abis/{GenericHarvester.d.ts => GenericRebalancer.d.ts} (96%)
 rename generated/abis/{GenericHarvester.js => GenericRebalancer.js} (97%)
 rename generated/abis/{MultiBlockHarvester.d.ts => MultiBlockRebalancer.d.ts} (95%)
 rename generated/abis/{MultiBlockHarvester.js => MultiBlockRebalancer.js} (96%)
 delete mode 100644 scripts/SetGenericHarvesterRoles.s.sol
 create mode 100644 scripts/SetGenericRebalancerRoles.s.sol
 rename scripts/{SetupGenericHarvesterExposure.s.sol => SetupGenericRebalancerExposure.s.sol} (61%)
 rename tests/units/{Harvester.t.sol => Rebalancer.t.sol} (59%)

diff --git a/README.md b/README.md
index f1ba6af..6356c98 100644
--- a/README.md
+++ b/README.md
@@ -73,7 +73,7 @@ Some changed has been made to the original Angle's Transmuter:
 | Swapper Facet         | [0x506Ba37aa8e265bE445913B9c4080852277f3c5a](https:///etherscan.io/address/0x506Ba37aa8e265bE445913B9c4080852277f3c5a) |
 | Parallelizer USDp     | [0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2](https:///etherscan.io/address/0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2) |
 | sUSDp (Savings)       | [0x0d45b129dc868963025Db79A9074EA9c9e32Cae4](https:///etherscan.io/address/0x0d45b129dc868963025Db79A9074EA9c9e32Cae4) |
-| GenericHarvester USDp | [0x36DA06796fD9d22BCD6287b66A87FfdadB12636C](https:///etherscan.io/address/0x36DA06796fD9d22BCD6287b66A87FfdadB12636C) |
+| GenericRebalancer USDp | [0x36DA06796fD9d22BCD6287b66A87FfdadB12636C](https:///etherscan.io/address/0x36DA06796fD9d22BCD6287b66A87FfdadB12636C) |
 
 ### Base
 
@@ -89,7 +89,7 @@ Some changed has been made to the original Angle's Transmuter:
 | Swapper Facet         | [0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7](https:///basescan.org/address/0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7) |
 | Parallelizer USDp     | [0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD](https:///basescan.org/address/0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD) |
 | sUSDp (Savings)       | [0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7](https:///basescan.org/address/0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7) |
-| GenericHarvester USDp | [0xCa43eCFCDFBA1fED003649e946Ae6091646B410a](https:///basescan.org/address/0xCa43eCFCDFBA1fED003649e946Ae6091646B410a) |
+| GenericRebalancer USDp | [0xCa43eCFCDFBA1fED003649e946Ae6091646B410a](https:///basescan.org/address/0xCa43eCFCDFBA1fED003649e946Ae6091646B410a) |
 
 ### Sonic
 
@@ -105,7 +105,7 @@ Some changed has been made to the original Angle's Transmuter:
 | Swapper Facet         | [0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF](https:///sonicscan.org/address/0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF) |
 | Parallelizer USDp     | [0xBEFBAe2330186F031b469e26283aCc66bb5F8826](https:///sonicscan.org/address/0xBEFBAe2330186F031b469e26283aCc66bb5F8826) |
 | sUSDp (Savings)       | [0xe8a3DA6f5ed1cf04c58ac7f6A7383641e877517b](https:///sonicscan.org/address/0xe8a3DA6f5ed1cf04c58ac7f6A7383641e877517b) |
-| GenericHarvester USDp | [0x120805265fA944834DC6e930De2995768806a9d2](https:///sonicscan.org/address/0x120805265fA944834DC6e930De2995768806a9d2) |
+| GenericRebalancer USDp | [0x120805265fA944834DC6e930De2995768806a9d2](https:///sonicscan.org/address/0x120805265fA944834DC6e930De2995768806a9d2) |
 
 #### HyperEVM
 
@@ -121,7 +121,7 @@ Some changed has been made to the original Angle's Transmuter:
 | Swapper Facet         | [0x1b2741dB9F46a0411852e4cC28dDC476851b5179](https:///www.hyperscan.com/address/0x1b2741dB9F46a0411852e4cC28dDC476851b5179) |
 | Parallelizer USDp     | [0x1250304F66404cd153fA39388DDCDAec7E0f1707](https:///www.hyperscan.com/address/0x1250304F66404cd153fA39388DDCDAec7E0f1707) |
 | sUSDp (Savings)       | [0x9B3a8f7CEC208e247d97dEE13313690977e24459](https:///www.hyperscan.com/address/0x9B3a8f7CEC208e247d97dEE13313690977e24459) |
-| GenericHarvester USDp | [0x57770C1721Eb35509f38210A935c8b1911db7E0e](https:///www.hyperscan.com/address/0x57770C1721Eb35509f38210A935c8b1911db7E0e) |
+| GenericRebalancer USDp | [0x57770C1721Eb35509f38210A935c8b1911db7E0e](https:///www.hyperscan.com/address/0x57770C1721Eb35509f38210A935c8b1911db7E0e) |
 
 #### Avalanche
 
@@ -137,7 +137,7 @@ Some changed has been made to the original Angle's Transmuter:
 | Swapper Facet         | [0x57265a3D7db8f4a4a155eadF6c7326926caC1490](https:///www.snowscan.xyz/address/0x57265a3D7db8f4a4a155eadF6c7326926caC1490) |
 | Parallelizer USDp     | [0x41d58951cbd12D4Ef49b0437897677bbF5547C80](https:///www.snowscan.xyz/address/0x41d58951cbd12D4Ef49b0437897677bbF5547C80) |
 | sUSDp (Savings)       | [0x9d92c21205383651610f90722131655a5b8ed3e0](https:///www.snowscan.xyz/address/0x9d92c21205383651610f90722131655a5b8ed3e0) |
-| GenericHarvester USDp | [0x0d45b129dc868963025db79a9074ea9c9e32cae4](https:///www.snowscan.xyz/address/0x0d45b129dc868963025db79a9074ea9c9e32cae4) |
+| GenericRebalancer USDp | [0x0d45b129dc868963025db79a9074ea9c9e32cae4](https:///www.snowscan.xyz/address/0x0d45b129dc868963025db79a9074ea9c9e32cae4) |
 
 ### Testnet
 
diff --git a/contracts/helpers/BaseHarvester.sol b/contracts/helpers/BaseRebalancer.sol
similarity index 97%
rename from contracts/helpers/BaseHarvester.sol
rename to contracts/helpers/BaseRebalancer.sol
index 5b618a7..79d21ba 100644
--- a/contracts/helpers/BaseHarvester.sol
+++ b/contracts/helpers/BaseRebalancer.sol
@@ -26,13 +26,13 @@ struct YieldBearingParams {
   uint96 maxSlippage;
 }
 
-/// @title BaseHarvester
+/// @title BaseRebalancer
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
-/// @dev Abstract contract for a harvester that aims at rebalancing a Parallelizer
-/// @dev This contract is an authorized fork of Angle's BaseHarvester contract:
-/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol
-abstract contract BaseHarvester is IHarvester, AccessManaged {
+/// @dev Abstract contract for a rebalancer that aims at rebalancing a Parallelizer
+/// @dev This contract is an authorized fork of Angle's BaseRebalancer contract:
+/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseRebalancer.sol
+abstract contract BaseRebalancer is IHarvester, AccessManaged {
   using SafeERC20 for IERC20;
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/contracts/helpers/GenericHarvester.sol b/contracts/helpers/GenericRebalancer.sol
similarity index 96%
rename from contracts/helpers/GenericHarvester.sol
rename to contracts/helpers/GenericRebalancer.sol
index a46f909..32dd100 100644
--- a/contracts/helpers/GenericHarvester.sol
+++ b/contracts/helpers/GenericRebalancer.sol
@@ -15,20 +15,20 @@ import { IERC4626 } from "contracts/interfaces/external/IERC4626.sol";
 
 import "../utils/Errors.sol";
 
-import { BaseHarvester, YieldBearingParams } from "./BaseHarvester.sol";
+import { BaseRebalancer, YieldBearingParams } from "./BaseRebalancer.sol";
 
 enum SwapType {
   VAULT,
   SWAP
 }
 
-/// @title GenericHarvester
+/// @title GenericRebalancer
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
 /// @dev Generic contract for trusted callers to adjust the reserves of Angle Parallelizer
-/// @dev This contract is an authorized fork of Angle's GenericHarvester contract:
-/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol
-contract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper {
+/// @dev This contract is an authorized fork of Angle's GenericRebalancer contract:
+/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericRebalancer.sol
+contract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapper {
   using SafeCast for uint256;
   using SafeERC20 for IERC20;
 
@@ -52,7 +52,7 @@ contract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper
     IERC3156FlashLender definitiveFlashloan
   )
     RouterSwapper(initialSwapRouter, initialTokenTransferAddress)
-    BaseHarvester(initialAuthority, definitivetokenP, definitiveParallelizer)
+    BaseRebalancer(initialAuthority, definitivetokenP, definitiveParallelizer)
   {
     if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();
     flashloan = definitiveFlashloan;
diff --git a/contracts/helpers/MultiBlockHarvester.sol b/contracts/helpers/MultiBlockRebalancer.sol
similarity index 96%
rename from contracts/helpers/MultiBlockHarvester.sol
rename to contracts/helpers/MultiBlockRebalancer.sol
index c050e75..d8b9697 100644
--- a/contracts/helpers/MultiBlockHarvester.sol
+++ b/contracts/helpers/MultiBlockRebalancer.sol
@@ -5,7 +5,7 @@ import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/I
 import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import { Math } from "@openzeppelin/contracts/utils/math/Math.sol";
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import { BaseHarvester, YieldBearingParams } from "./BaseHarvester.sol";
+import { BaseRebalancer, YieldBearingParams } from "./BaseRebalancer.sol";
 import { IParallelizer } from "contracts/interfaces/IParallelizer.sol";
 import { ITokenP } from "contracts/interfaces/ITokenP.sol";
 import { IPool } from "contracts/interfaces/IPool.sol";
@@ -13,13 +13,13 @@ import { IPool } from "contracts/interfaces/IPool.sol";
 import "../utils/Errors.sol";
 import "../utils/Constants.sol";
 
-/// @title MultiBlockHarvester
+/// @title MultiBlockRebalancer
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
 /// @dev Contract to harvest yield from multiple yield bearing assets in multiple blocks transactions
-/// @dev This contract is an authorized fork of Angle's MultiBlockHarvester contract:
-/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/MultiBlockHarvester.sol
-contract MultiBlockHarvester is BaseHarvester {
+/// @dev This contract is an authorized fork of Angle's MultiBlockRebalancer contract:
+/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/MultiBlockRebalancer.sol
+contract MultiBlockRebalancer is BaseRebalancer {
   using SafeERC20 for IERC20;
   using Math for uint256;
 
@@ -39,7 +39,7 @@ contract MultiBlockHarvester is BaseHarvester {
     ITokenP definitivetokenP,
     IParallelizer definitiveParallelizer
   )
-    BaseHarvester(initialAuthority, definitivetokenP, definitiveParallelizer)
+    BaseRebalancer(initialAuthority, definitivetokenP, definitiveParallelizer)
   { }
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/deploy/config/avalanche/config.json b/deploy/config/avalanche/config.json
index 5d10d47..3594b30 100644
--- a/deploy/config/avalanche/config.json
+++ b/deploy/config/avalanche/config.json
@@ -59,7 +59,7 @@
       "symbol": "sUSDp"
     }
   },
-  "genericHarvester": {
+  "genericRebalancer": {
     "usdp": {
       "swapRouter": "0x88de50b233052e4fb783d4f6db78cc34fea3e9fc",
       "tokenTransferAddress": "0x88de50b233052e4fb783d4f6db78cc34fea3e9fc",
diff --git a/deploy/config/base/config.json b/deploy/config/base/config.json
index f6a6c4d..beb60e7 100644
--- a/deploy/config/base/config.json
+++ b/deploy/config/base/config.json
@@ -59,7 +59,7 @@
       "symbol": "sUSDp"
     }
   },
-  "genericHarvester": {
+  "genericRebalancer": {
     "usdp": {
       "swapRouter": "0x19ceead7105607cd444f5ad10dd51356436095a1",
       "tokenTransferAddress": "0x19ceead7105607cd444f5ad10dd51356436095a1",
diff --git a/deploy/config/hyperevm/config.json b/deploy/config/hyperevm/config.json
index 3af5446..e98b3dc 100644
--- a/deploy/config/hyperevm/config.json
+++ b/deploy/config/hyperevm/config.json
@@ -62,7 +62,7 @@
       "symbol": "sUSDp"
     }
   },
-  "genericHarvester": {
+  "genericRebalancer": {
     "usdp": {
       "swapRouter": "0x744489ee3d540777a66f2cf297479745e0852f7a",
       "tokenTransferAddress": "0x744489ee3d540777a66f2cf297479745e0852f7a",
diff --git a/deploy/config/mainnet/config.json b/deploy/config/mainnet/config.json
index 83cbc8d..236a4ff 100644
--- a/deploy/config/mainnet/config.json
+++ b/deploy/config/mainnet/config.json
@@ -99,7 +99,7 @@
       "symbol": "sUSDp"
     }
   },
-  "genericHarvester": {
+  "genericRebalancer": {
     "usdp": {
       "swapRouter": "0xcf5540fffcdc3d510b18bfca6d2b9987b0772559",
       "tokenTransferAddress": "0xcf5540fffcdc3d510b18bfca6d2b9987b0772559",
diff --git a/deploy/config/sonic/config.json b/deploy/config/sonic/config.json
index 53a7ba0..4a2a45c 100644
--- a/deploy/config/sonic/config.json
+++ b/deploy/config/sonic/config.json
@@ -99,7 +99,7 @@
       "symbol": "sUSDp"
     }
   },
-  "genericHarvester": {
+  "genericRebalancer": {
     "usdp": {
       "swapRouter": "0xaC041Df48dF9791B0654f1Dbbf2CC8450C5f2e9D",
       "tokenTransferAddress": "0xaC041Df48dF9791B0654f1Dbbf2CC8450C5f2e9D",
diff --git a/deploy/scripts/GenericHarvester.ts b/deploy/scripts/GenericRebalancer.ts
similarity index 71%
rename from deploy/scripts/GenericHarvester.ts
rename to deploy/scripts/GenericRebalancer.ts
index c6c3b86..69e89a2 100644
--- a/deploy/scripts/GenericHarvester.ts
+++ b/deploy/scripts/GenericRebalancer.ts
@@ -4,7 +4,7 @@ import { deployScript, artifacts } from "@rocketh";
 import { checkAddressValid, parseToConfigData } from "../utils";
 import { readFileSync } from "fs";
 
-const contractName = "GenericHarvester";
+const contractName = "GenericRebalancer";
 
 const token = "USDp";
 
@@ -28,26 +28,26 @@ export default deployScript(
       "Invalid tokenP address",
     );
 
-    const genericHarvesterConfig = config.genericHarvester[token.toLowerCase() as keyof typeof config.genericHarvester];
-    const swapRouter = checkAddressValid(genericHarvesterConfig.swapRouter, "Invalid swapRouter address");
+    const genericRebalancerConfig = config.genericRebalancer[token.toLowerCase() as keyof typeof config.genericRebalancer];
+    const swapRouter = checkAddressValid(genericRebalancerConfig.swapRouter, "Invalid swapRouter address");
     const tokenTransferAddress = checkAddressValid(
-      genericHarvesterConfig.tokenTransferAddress,
+      genericRebalancerConfig.tokenTransferAddress,
       "Invalid tokenTransferAddress address",
     );
 
-    const flashloan = checkAddressValid(genericHarvesterConfig.flashloan, "Invalid flashloan address");
+    const flashloan = checkAddressValid(genericRebalancerConfig.flashloan, "Invalid flashloan address");
     const parallelizer = get(`Parallelizer_${token}`);
     if (!parallelizer) {
       throw new Error(`Parallelizer_${token} not found`);
     }
 
-    const genericHarvester = await deploy(`${contractName}_${token}`, {
+    const genericRebalancer = await deploy(`${contractName}_${token}`, {
       account: deployer,
-      artifact: artifacts.GenericHarvester,
+      artifact: artifacts.GenericRebalancer,
       args: [tokenTransferAddress, swapRouter, tokenP, parallelizer.address, accessManager, flashloan],
     });
 
-    console.log(`Deployed ${contractName}_${token}, network: ${chainName}, address: ${genericHarvester.address}`);
+    console.log(`Deployed ${contractName}_${token}, network: ${chainName}, address: ${genericRebalancer.address}`);
   },
   {
     tags: [contractName],
diff --git a/deploy/utils/types.ts b/deploy/utils/types.ts
index 68fbdb3..902fc18 100644
--- a/deploy/utils/types.ts
+++ b/deploy/utils/types.ts
@@ -81,7 +81,7 @@ export type SavingsConfig = {
   symbol: string;
 };
 
-export type GenericHarvesterConfig = {
+export type GenericRebalancerConfig = {
   swapRouter: Address;
   tokenTransferAddress: Address;
   flashloan: Address;
@@ -101,7 +101,7 @@ export type ConfigData = {
   savings: {
     [tokenP: string]: SavingsConfig;
   };
-  genericHarvester: {
-    [tokenP: string]: GenericHarvesterConfig;
+  genericRebalancer: {
+    [tokenP: string]: GenericRebalancerConfig;
   };
 };
diff --git a/generated/abis/BaseHarvester.d.ts b/generated/abis/BaseRebalancer.d.ts
similarity index 94%
rename from generated/abis/BaseHarvester.d.ts
rename to generated/abis/BaseRebalancer.d.ts
index b8e44df..c2b2c58 100644
--- a/generated/abis/BaseHarvester.d.ts
+++ b/generated/abis/BaseRebalancer.d.ts
@@ -1,4 +1,4 @@
-export type Abi_BaseHarvester = [
+export type Abi_BaseRebalancer = [
   {
     "inputs": [
       {
@@ -207,25 +207,6 @@ export type Abi_BaseHarvester = [
     "stateMutability": "view",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "maxTokenSlippage",
-    "outputs": [
-      {
-        "internalType": "uint96",
-        "name": "",
-        "type": "uint96"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [],
     "name": "parallelizer",
@@ -438,4 +419,4 @@ export type Abi_BaseHarvester = [
     "type": "function"
   }
 ];
-export declare const Abi_BaseHarvester: Abi_BaseHarvester;
+export declare const Abi_BaseRebalancer: Abi_BaseRebalancer;
diff --git a/generated/abis/BaseHarvester.js b/generated/abis/BaseRebalancer.js
similarity index 95%
rename from generated/abis/BaseHarvester.js
rename to generated/abis/BaseRebalancer.js
index 19475d9..9fbc394 100644
--- a/generated/abis/BaseHarvester.js
+++ b/generated/abis/BaseRebalancer.js
@@ -1,4 +1,4 @@
-export const Abi_BaseHarvester = /** @type {const} **/ ([
+export const Abi_BaseRebalancer = /** @type {const} **/ ([
   {
     "inputs": [
       {
@@ -207,25 +207,6 @@ export const Abi_BaseHarvester = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "maxTokenSlippage",
-    "outputs": [
-      {
-        "internalType": "uint96",
-        "name": "",
-        "type": "uint96"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [],
     "name": "parallelizer",
diff --git a/generated/abis/DiamondInitializer.d.ts b/generated/abis/DiamondInitializer.d.ts
index 618141d..b3d3555 100644
--- a/generated/abis/DiamondInitializer.d.ts
+++ b/generated/abis/DiamondInitializer.d.ts
@@ -112,6 +112,31 @@ export type Abi_DiamondInitializer = [
     "name": "OracleSet",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "collateral",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "previousTarget",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newTarget",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleTargetUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
diff --git a/generated/abis/DiamondInitializer.js b/generated/abis/DiamondInitializer.js
index 421dce0..383de8b 100644
--- a/generated/abis/DiamondInitializer.js
+++ b/generated/abis/DiamondInitializer.js
@@ -112,6 +112,31 @@ export const Abi_DiamondInitializer = /** @type {const} **/ ([
     "name": "OracleSet",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "collateral",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "previousTarget",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newTarget",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleTargetUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
diff --git a/generated/abis/GenericHarvester.d.ts b/generated/abis/GenericRebalancer.d.ts
similarity index 96%
rename from generated/abis/GenericHarvester.d.ts
rename to generated/abis/GenericRebalancer.d.ts
index d62a89e..2649a77 100644
--- a/generated/abis/GenericHarvester.d.ts
+++ b/generated/abis/GenericRebalancer.d.ts
@@ -1,4 +1,4 @@
-export type Abi_GenericHarvester = [
+export type Abi_GenericRebalancer = [
   {
     "inputs": [
       {
@@ -88,6 +88,11 @@ export type Abi_GenericHarvester = [
     "name": "NotTrustedOrGuardian",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "RouterDidNotConsumeAllTokens",
+    "type": "error"
+  },
   {
     "inputs": [
       {
@@ -352,25 +357,6 @@ export type Abi_GenericHarvester = [
     "stateMutability": "view",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "maxTokenSlippage",
-    "outputs": [
-      {
-        "internalType": "uint96",
-        "name": "",
-        "type": "uint96"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [
       {
@@ -692,4 +678,4 @@ export type Abi_GenericHarvester = [
     "type": "function"
   }
 ];
-export declare const Abi_GenericHarvester: Abi_GenericHarvester;
+export declare const Abi_GenericRebalancer: Abi_GenericRebalancer;
diff --git a/generated/abis/GenericHarvester.js b/generated/abis/GenericRebalancer.js
similarity index 97%
rename from generated/abis/GenericHarvester.js
rename to generated/abis/GenericRebalancer.js
index 475cb12..626c4fb 100644
--- a/generated/abis/GenericHarvester.js
+++ b/generated/abis/GenericRebalancer.js
@@ -1,4 +1,4 @@
-export const Abi_GenericHarvester = /** @type {const} **/ ([
+export const Abi_GenericRebalancer = /** @type {const} **/ ([
   {
     "inputs": [
       {
@@ -88,6 +88,11 @@ export const Abi_GenericHarvester = /** @type {const} **/ ([
     "name": "NotTrustedOrGuardian",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "RouterDidNotConsumeAllTokens",
+    "type": "error"
+  },
   {
     "inputs": [
       {
@@ -352,25 +357,6 @@ export const Abi_GenericHarvester = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "maxTokenSlippage",
-    "outputs": [
-      {
-        "internalType": "uint96",
-        "name": "",
-        "type": "uint96"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [
       {
diff --git a/generated/abis/LibOracle.d.ts b/generated/abis/LibOracle.d.ts
index 3c75f74..6705c7d 100644
--- a/generated/abis/LibOracle.d.ts
+++ b/generated/abis/LibOracle.d.ts
@@ -1,2 +1,28 @@
-export type Abi_LibOracle = [];
+export type Abi_LibOracle = [
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "collateral",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "previousTarget",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newTarget",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleTargetUpdated",
+    "type": "event"
+  }
+];
 export declare const Abi_LibOracle: Abi_LibOracle;
diff --git a/generated/abis/LibOracle.js b/generated/abis/LibOracle.js
index d801996..69e7551 100644
--- a/generated/abis/LibOracle.js
+++ b/generated/abis/LibOracle.js
@@ -1 +1,27 @@
-export const Abi_LibOracle = /** @type {const} **/ ([]);
\ No newline at end of file
+export const Abi_LibOracle = /** @type {const} **/ ([
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "collateral",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "previousTarget",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newTarget",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleTargetUpdated",
+    "type": "event"
+  }
+]);
\ No newline at end of file
diff --git a/generated/abis/MultiBlockHarvester.d.ts b/generated/abis/MultiBlockRebalancer.d.ts
similarity index 95%
rename from generated/abis/MultiBlockHarvester.d.ts
rename to generated/abis/MultiBlockRebalancer.d.ts
index 1320704..96cff3f 100644
--- a/generated/abis/MultiBlockHarvester.d.ts
+++ b/generated/abis/MultiBlockRebalancer.d.ts
@@ -1,4 +1,4 @@
-export type Abi_MultiBlockHarvester = [
+export type Abi_MultiBlockRebalancer = [
   {
     "inputs": [
       {
@@ -261,25 +261,6 @@ export type Abi_MultiBlockHarvester = [
     "stateMutability": "view",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "maxTokenSlippage",
-    "outputs": [
-      {
-        "internalType": "uint96",
-        "name": "",
-        "type": "uint96"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [],
     "name": "parallelizer",
@@ -529,4 +510,4 @@ export type Abi_MultiBlockHarvester = [
     "type": "function"
   }
 ];
-export declare const Abi_MultiBlockHarvester: Abi_MultiBlockHarvester;
+export declare const Abi_MultiBlockRebalancer: Abi_MultiBlockRebalancer;
diff --git a/generated/abis/MultiBlockHarvester.js b/generated/abis/MultiBlockRebalancer.js
similarity index 96%
rename from generated/abis/MultiBlockHarvester.js
rename to generated/abis/MultiBlockRebalancer.js
index cd433b6..c2abb49 100644
--- a/generated/abis/MultiBlockHarvester.js
+++ b/generated/abis/MultiBlockRebalancer.js
@@ -1,4 +1,4 @@
-export const Abi_MultiBlockHarvester = /** @type {const} **/ ([
+export const Abi_MultiBlockRebalancer = /** @type {const} **/ ([
   {
     "inputs": [
       {
@@ -261,25 +261,6 @@ export const Abi_MultiBlockHarvester = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
-  {
-    "inputs": [
-      {
-        "internalType": "address",
-        "name": "",
-        "type": "address"
-      }
-    ],
-    "name": "maxTokenSlippage",
-    "outputs": [
-      {
-        "internalType": "uint96",
-        "name": "",
-        "type": "uint96"
-      }
-    ],
-    "stateMutability": "view",
-    "type": "function"
-  },
   {
     "inputs": [],
     "name": "parallelizer",
diff --git a/generated/abis/SettersGovernor.d.ts b/generated/abis/SettersGovernor.d.ts
index 86591a0..7b99c32 100644
--- a/generated/abis/SettersGovernor.d.ts
+++ b/generated/abis/SettersGovernor.d.ts
@@ -283,6 +283,31 @@ export type Abi_SettersGovernor = [
     "name": "OracleSet",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "collateral",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "previousTarget",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newTarget",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleTargetUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
diff --git a/generated/abis/SettersGovernor.js b/generated/abis/SettersGovernor.js
index b75adf4..b09aaa5 100644
--- a/generated/abis/SettersGovernor.js
+++ b/generated/abis/SettersGovernor.js
@@ -283,6 +283,31 @@ export const Abi_SettersGovernor = /** @type {const} **/ ([
     "name": "OracleSet",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "collateral",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "previousTarget",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "newTarget",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleTargetUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
diff --git a/generated/abis/index.d.ts b/generated/abis/index.d.ts
index 77a69c7..a554fcb 100644
--- a/generated/abis/index.d.ts
+++ b/generated/abis/index.d.ts
@@ -1,6 +1,6 @@
-export {Abi_BaseHarvester as BaseHarvester} from "./BaseHarvester.js"
-export {Abi_GenericHarvester as GenericHarvester} from "./GenericHarvester.js"
-export {Abi_MultiBlockHarvester as MultiBlockHarvester} from "./MultiBlockHarvester.js"
+export {Abi_BaseRebalancer as BaseRebalancer} from "./BaseRebalancer.js"
+export {Abi_GenericRebalancer as GenericRebalancer} from "./GenericRebalancer.js"
+export {Abi_MultiBlockRebalancer as MultiBlockRebalancer} from "./MultiBlockRebalancer.js"
 export {Abi_IDiamondCut as IDiamondCut} from "./IDiamondCut.js"
 export {Abi_IDiamondEtherscan as IDiamondEtherscan} from "./IDiamondEtherscan.js"
 export {Abi_IDiamondLoupe as IDiamondLoupe} from "./IDiamondLoupe.js"
@@ -58,6 +58,7 @@ export {Abi_BaseSavings as BaseSavings} from "./BaseSavings.js"
 export {Abi_EIP3009 as EIP3009} from "./EIP3009.js"
 export {Abi_Savings as Savings} from "./Savings.js"
 export {Abi_SavingsEIP3009 as SavingsEIP3009} from "./SavingsEIP3009.js"
+export {Abi_SavingsSunset as SavingsSunset} from "./SavingsSunset.js"
 export {Abi_SavingsNameable as SavingsNameable} from "./SavingsNameable.js"
 export {Abi_AccessManaged as AccessManaged} from "./AccessManaged.js"
 export {Abi_AccessManagedUpgradeable as AccessManagedUpgradeable} from "./AccessManagedUpgradeable.js"
diff --git a/generated/abis/index.js b/generated/abis/index.js
index 77a69c7..a554fcb 100644
--- a/generated/abis/index.js
+++ b/generated/abis/index.js
@@ -1,6 +1,6 @@
-export {Abi_BaseHarvester as BaseHarvester} from "./BaseHarvester.js"
-export {Abi_GenericHarvester as GenericHarvester} from "./GenericHarvester.js"
-export {Abi_MultiBlockHarvester as MultiBlockHarvester} from "./MultiBlockHarvester.js"
+export {Abi_BaseRebalancer as BaseRebalancer} from "./BaseRebalancer.js"
+export {Abi_GenericRebalancer as GenericRebalancer} from "./GenericRebalancer.js"
+export {Abi_MultiBlockRebalancer as MultiBlockRebalancer} from "./MultiBlockRebalancer.js"
 export {Abi_IDiamondCut as IDiamondCut} from "./IDiamondCut.js"
 export {Abi_IDiamondEtherscan as IDiamondEtherscan} from "./IDiamondEtherscan.js"
 export {Abi_IDiamondLoupe as IDiamondLoupe} from "./IDiamondLoupe.js"
@@ -58,6 +58,7 @@ export {Abi_BaseSavings as BaseSavings} from "./BaseSavings.js"
 export {Abi_EIP3009 as EIP3009} from "./EIP3009.js"
 export {Abi_Savings as Savings} from "./Savings.js"
 export {Abi_SavingsEIP3009 as SavingsEIP3009} from "./SavingsEIP3009.js"
+export {Abi_SavingsSunset as SavingsSunset} from "./SavingsSunset.js"
 export {Abi_SavingsNameable as SavingsNameable} from "./SavingsNameable.js"
 export {Abi_AccessManaged as AccessManaged} from "./AccessManaged.js"
 export {Abi_AccessManagedUpgradeable as AccessManagedUpgradeable} from "./AccessManagedUpgradeable.js"
diff --git a/libs/helpers/CommonUtils.sol b/libs/helpers/CommonUtils.sol
index dd45412..35cac93 100644
--- a/libs/helpers/CommonUtils.sol
+++ b/libs/helpers/CommonUtils.sol
@@ -209,10 +209,10 @@ contract CommonUtils is CommonBase, JsonReader {
       return "USD.Treasury";
     } else if (name == ContractType.FlashLoan) {
       return "FlashLoan";
-    } else if (name == ContractType.MultiBlockHarvester) {
-      return "USD.MultiBlockHarvester";
-    } else if (name == ContractType.GenericHarvester) {
-      return "USD.GenericHarvester";
+    } else if (name == ContractType.MultiBlockRebalancer) {
+      return "USD.MultiBlockRebalancer";
+    } else if (name == ContractType.GenericRebalancer) {
+      return "USD.GenericRebalancer";
     } else if (name == ContractType.Harvester) {
       return "USD.Harvester";
     } else if (name == ContractType.Rebalancer) {
diff --git a/libs/helpers/Constants.sol b/libs/helpers/Constants.sol
index 4f7ee3b..0902649 100644
--- a/libs/helpers/Constants.sol
+++ b/libs/helpers/Constants.sol
@@ -23,8 +23,8 @@ enum ContractType {
   TreasuryEURp,
   TreasuryUSDp,
   FlashLoan,
-  MultiBlockHarvester,
-  GenericHarvester,
+  MultiBlockRebalancer,
+  GenericRebalancer,
   Harvester,
   Rebalancer,
   MulticallWithFailure,
diff --git a/libs/helpers/registry/registry.json b/libs/helpers/registry/registry.json
index ba3563c..c99988a 100644
--- a/libs/helpers/registry/registry.json
+++ b/libs/helpers/registry/registry.json
@@ -14,8 +14,8 @@
       "Transmuter": "0x000000000000000000000000000000000000000d",
       "Treasury": "0x000000000000000000000000000000000000000f",
       "Harvester": "0x0000000000000000000000000000000000000013",
-      "GenericHarvester": "0x0000000000000000000000000000000000000012",
-      "MultiBlockHarvester": "0x0000000000000000000000000000000000000011",
+      "GenericRebalancer": "0x0000000000000000000000000000000000000012",
+      "MultiBlockRebalancer": "0x0000000000000000000000000000000000000011",
       "Rebalancer": "0x0000000000000000000000000000000000000014"
     },
     "PRL": "0x0000000000000000000000000000000000000005",
diff --git a/scripts/SetGenericHarvesterRoles.s.sol b/scripts/SetGenericHarvesterRoles.s.sol
deleted file mode 100644
index 4a37568..0000000
--- a/scripts/SetGenericHarvesterRoles.s.sol
+++ /dev/null
@@ -1,26 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.28;
-
-import "./Base.s.sol";
-
-import { GenericHarvester } from "contracts/helpers/GenericHarvester.sol";
-import { BaseHarvester } from "contracts/helpers/BaseHarvester.sol";
-
-contract SetGenericHarvesterRoles is BaseScript {
-  address genericHarvester = 0x57770C1721Eb35509f38210A935c8b1911db7E0e;
-
-  function run() public broadcast {
-    bytes4[] memory guardianSelectors = new bytes4[](5);
-    guardianSelectors[0] = BaseHarvester.setYieldBearingAssetData.selector;
-    guardianSelectors[1] = BaseHarvester.setMaxSlippage.selector;
-    guardianSelectors[2] = BaseHarvester.toggleTrusted.selector;
-    guardianSelectors[3] = BaseHarvester.recoverERC20.selector;
-    guardianSelectors[4] = BaseHarvester.setTargetExposure.selector;
-    accessManager.setTargetFunctionRole(genericHarvester, guardianSelectors, Roles.GUARDIAN_ROLE);
-
-    bytes4[] memory governorSelectors = new bytes4[](2);
-    governorSelectors[0] = GenericHarvester.setTokenTransferAddress.selector;
-    governorSelectors[1] = GenericHarvester.setSwapRouter.selector;
-    accessManager.setTargetFunctionRole(genericHarvester, governorSelectors, Roles.GOVERNOR_ROLE);
-  }
-}
diff --git a/scripts/SetGenericRebalancerRoles.s.sol b/scripts/SetGenericRebalancerRoles.s.sol
new file mode 100644
index 0000000..6f81662
--- /dev/null
+++ b/scripts/SetGenericRebalancerRoles.s.sol
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import "./Base.s.sol";
+
+import { GenericRebalancer } from "contracts/helpers/GenericRebalancer.sol";
+import { BaseRebalancer } from "contracts/helpers/BaseRebalancer.sol";
+
+contract SetGenericRebalancerRoles is BaseScript {
+  address genericRebalancer = 0x57770C1721Eb35509f38210A935c8b1911db7E0e;
+
+  function run() public broadcast {
+    bytes4[] memory guardianSelectors = new bytes4[](5);
+    guardianSelectors[0] = BaseRebalancer.setYieldBearingAssetData.selector;
+    guardianSelectors[1] = BaseRebalancer.setMaxSlippage.selector;
+    guardianSelectors[2] = BaseRebalancer.toggleTrusted.selector;
+    guardianSelectors[3] = BaseRebalancer.recoverERC20.selector;
+    guardianSelectors[4] = BaseRebalancer.setTargetExposure.selector;
+    accessManager.setTargetFunctionRole(genericRebalancer, guardianSelectors, Roles.GUARDIAN_ROLE);
+
+    bytes4[] memory governorSelectors = new bytes4[](2);
+    governorSelectors[0] = GenericRebalancer.setTokenTransferAddress.selector;
+    governorSelectors[1] = GenericRebalancer.setSwapRouter.selector;
+    accessManager.setTargetFunctionRole(genericRebalancer, governorSelectors, Roles.GOVERNOR_ROLE);
+  }
+}
diff --git a/scripts/SetupGenericHarvesterExposure.s.sol b/scripts/SetupGenericRebalancerExposure.s.sol
similarity index 61%
rename from scripts/SetupGenericHarvesterExposure.s.sol
rename to scripts/SetupGenericRebalancerExposure.s.sol
index 72c9c7a..6b3ccc4 100644
--- a/scripts/SetupGenericHarvesterExposure.s.sol
+++ b/scripts/SetupGenericRebalancerExposure.s.sol
@@ -3,15 +3,15 @@ pragma solidity 0.8.28;
 
 import "./Base.s.sol";
 
-import { GenericHarvester } from "contracts/helpers/GenericHarvester.sol";
-import { BaseHarvester } from "contracts/helpers/BaseHarvester.sol";
+import { GenericRebalancer } from "contracts/helpers/GenericRebalancer.sol";
+import { BaseRebalancer } from "contracts/helpers/BaseRebalancer.sol";
 
-contract SetupGenericHarvesterExposure is BaseScript {
-  BaseHarvester genericHarvester = BaseHarvester(0x57770C1721Eb35509f38210A935c8b1911db7E0e);
+contract SetupGenericRebalancerExposure is BaseScript {
+  BaseRebalancer genericRebalancer = BaseRebalancer(0x57770C1721Eb35509f38210A935c8b1911db7E0e);
 
   function run() public broadcast {
     accessManager.grantRole(Roles.GUARDIAN_ROLE, broadcaster, 0);
-    genericHarvester.setYieldBearingAssetData(
+    genericRebalancer.setYieldBearingAssetData(
       // yieldBearingAsset
       address(0x211Cc4DD073734dA055fbF44a2b4667d5E5fE5d2),
       // asset
diff --git a/tests/units/Harvester.t.sol b/tests/units/Rebalancer.t.sol
similarity index 59%
rename from tests/units/Harvester.t.sol
rename to tests/units/Rebalancer.t.sol
index 5c3aa6d..7312797 100644
--- a/tests/units/Harvester.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -2,15 +2,15 @@
 
 pragma solidity 0.8.28;
 
-import { MultiBlockHarvester } from "contracts/helpers/MultiBlockHarvester.sol";
+import { MultiBlockRebalancer } from "contracts/helpers/MultiBlockRebalancer.sol";
 import { IParallelizer } from "contracts/interfaces/IParallelizer.sol";
 import "contracts/utils/Constants.sol";
 import "contracts/utils/Errors.sol" as Errors;
 
 import { Fixture } from "../Fixture.sol";
 
-contract Test_Harvester_MaxSlippage is Fixture {
-  MultiBlockHarvester internal harvester;
+contract Test_Rebalancer_MaxSlippage is Fixture {
+  MultiBlockRebalancer internal rebalancer;
 
   address internal yieldBearingAsset;
 
@@ -18,36 +18,36 @@ contract Test_Harvester_MaxSlippage is Fixture {
     super.setUp();
 
     yieldBearingAsset = address(eurY);
-    harvester = new MultiBlockHarvester(address(accessManager), tokenP, IParallelizer(address(parallelizer)));
+    rebalancer = new MultiBlockRebalancer(address(accessManager), tokenP, IParallelizer(address(parallelizer)));
 
     vm.startPrank(governor);
     accessManager.setTargetFunctionRole(
-      address(harvester), getGuardianBaseHarvesterSelectorAccess(), GUARDIAN_ROLE
+      address(rebalancer), getGuardianBaseRebalancerSelectorAccess(), GUARDIAN_ROLE
     );
     accessManager.grantRole(GUARDIAN_ROLE, guardian, 0);
     vm.stopPrank();
 
     vm.prank(guardian);
-    harvester.setYieldBearingAssetData(yieldBearingAsset, address(eurA), 5e8, 1e8, 9e8, 1, 5e7);
+    rebalancer.setYieldBearingAssetData(yieldBearingAsset, address(eurA), 5e8, 1e8, 9e8, 1, 5e7);
   }
 
   function test_SetMaxSlippage_UpdatesTheLiveLimit() public {
     vm.prank(guardian);
-    harvester.setMaxSlippage(yieldBearingAsset, 1e7);
+    rebalancer.setMaxSlippage(yieldBearingAsset, 1e7);
 
-    (,,,,, uint96 maxSlippage) = harvester.yieldBearingData(yieldBearingAsset);
+    (,,,,, uint96 maxSlippage) = rebalancer.yieldBearingData(yieldBearingAsset);
     assertEq(maxSlippage, 1e7);
   }
 
   function test_RevertWhen_SetMaxSlippageIsFullSlippage() public {
     vm.prank(guardian);
     vm.expectRevert(Errors.InvalidParam.selector);
-    harvester.setMaxSlippage(yieldBearingAsset, 1e9);
+    rebalancer.setMaxSlippage(yieldBearingAsset, 1e9);
   }
 
   function test_RevertWhen_SetMaxSlippageNotGuardian() public {
     vm.prank(alice);
     vm.expectRevert(abi.encodeWithSelector(Errors.AccessManagedUnauthorized.selector, alice));
-    harvester.setMaxSlippage(yieldBearingAsset, 1e7);
+    rebalancer.setMaxSlippage(yieldBearingAsset, 1e7);
   }
 }
diff --git a/tests/utils/ConfigAccessManager.sol b/tests/utils/ConfigAccessManager.sol
index 13c08ee..c603576 100644
--- a/tests/utils/ConfigAccessManager.sol
+++ b/tests/utils/ConfigAccessManager.sol
@@ -7,9 +7,9 @@ import { UUPSUpgradeable } from "@openzeppelin/contracts/proxy/utils/UUPSUpgrade
 import { Savings } from "contracts/savings/Savings.sol";
 import { SavingsNameable } from "contracts/savings/nameable/SavingsNameable.sol";
 import { BaseSavings } from "contracts/savings/BaseSavings.sol";
-import { BaseHarvester } from "contracts/helpers/BaseHarvester.sol";
-import { MultiBlockHarvester } from "contracts/helpers/MultiBlockHarvester.sol";
-import { GenericHarvester } from "contracts/helpers/GenericHarvester.sol";
+import { BaseRebalancer } from "contracts/helpers/BaseRebalancer.sol";
+import { MultiBlockRebalancer } from "contracts/helpers/MultiBlockRebalancer.sol";
+import { GenericRebalancer } from "contracts/helpers/GenericRebalancer.sol";
 import { SettersGuardian } from "contracts/parallelizer/facets/SettersGuardian.sol";
 import { SettersGovernor } from "contracts/parallelizer/facets/SettersGovernor.sol";
 import { DiamondEtherscan } from "contracts/parallelizer/facets/DiamondEtherscan.sol";
@@ -62,26 +62,26 @@ abstract contract ConfigAccessManager is Helper {
     return selectors;
   }
 
-  function getGuardianBaseHarvesterSelectorAccess() internal pure returns (bytes4[] memory) {
+  function getGuardianBaseRebalancerSelectorAccess() internal pure returns (bytes4[] memory) {
     bytes4[] memory selectors = new bytes4[](5);
-    selectors[0] = BaseHarvester.setYieldBearingAssetData.selector;
-    selectors[1] = BaseHarvester.setMaxSlippage.selector;
-    selectors[2] = BaseHarvester.toggleTrusted.selector;
-    selectors[3] = BaseHarvester.recoverERC20.selector;
-    selectors[4] = BaseHarvester.setTargetExposure.selector;
+    selectors[0] = BaseRebalancer.setYieldBearingAssetData.selector;
+    selectors[1] = BaseRebalancer.setMaxSlippage.selector;
+    selectors[2] = BaseRebalancer.toggleTrusted.selector;
+    selectors[3] = BaseRebalancer.recoverERC20.selector;
+    selectors[4] = BaseRebalancer.setTargetExposure.selector;
     return selectors;
   }
 
-  function getGovernorMultiBlockHarvesterSelectorAccess() internal pure returns (bytes4[] memory) {
+  function getGovernorMultiBlockRebalancerSelectorAccess() internal pure returns (bytes4[] memory) {
     bytes4[] memory selectors = new bytes4[](1);
-    selectors[0] = MultiBlockHarvester.setYieldBearingToDepositAddress.selector;
+    selectors[0] = MultiBlockRebalancer.setYieldBearingToDepositAddress.selector;
     return selectors;
   }
 
-  function getGovernorGenericHarvesterSelectorAccess() internal pure returns (bytes4[] memory) {
+  function getGovernorGenericRebalancerSelectorAccess() internal pure returns (bytes4[] memory) {
     bytes4[] memory selectors = new bytes4[](2);
-    selectors[0] = GenericHarvester.setTokenTransferAddress.selector;
-    selectors[1] = GenericHarvester.setSwapRouter.selector;
+    selectors[0] = GenericRebalancer.setTokenTransferAddress.selector;
+    selectors[1] = GenericRebalancer.setSwapRouter.selector;
     return selectors;
   }
 

From a4722334f5c9a0ab4b2194ddd64a90ae20620e8e Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 10:49:28 +0300
Subject: [PATCH 07/38] refactor(rebalancer): rename IHarvester and drop stale
 deployment records

Completes the rename: the interface follows the contracts that implement
it. The upstream reference to Angle's IHarvester is left as written since
it names a file in their repository.

The GenericHarvester deployment records are removed. They are internal
helper contracts, no code resolves them by name, and the entries would
otherwise point at an implementation this repository no longer builds.
---
 contracts/helpers/BaseRebalancer.sol          |    4 +-
 .../{IHarvester.sol => IRebalancer.sol}       |    4 +-
 .../avalanche/GenericHarvester_USDp.json      | 1190 -----------------
 deployments/base/GenericHarvester_USDp.json   | 1124 ----------------
 .../hyperevm/GenericHarvester_USDp.json       | 1124 ----------------
 .../mainnet/GenericHarvester_USDp.json        | 1124 ----------------
 deployments/sonic/GenericHarvester_USDp.json  | 1124 ----------------
 .../{IHarvester.d.ts => IRebalancer.d.ts}     |    4 +-
 .../abis/{IHarvester.js => IRebalancer.js}    |    2 +-
 generated/abis/index.d.ts                     |    2 +-
 generated/abis/index.js                       |    2 +-
 11 files changed, 9 insertions(+), 5695 deletions(-)
 rename contracts/interfaces/{IHarvester.sol => IRebalancer.sol} (94%)
 delete mode 100644 deployments/avalanche/GenericHarvester_USDp.json
 delete mode 100644 deployments/base/GenericHarvester_USDp.json
 delete mode 100644 deployments/hyperevm/GenericHarvester_USDp.json
 delete mode 100644 deployments/mainnet/GenericHarvester_USDp.json
 delete mode 100644 deployments/sonic/GenericHarvester_USDp.json
 rename generated/abis/{IHarvester.d.ts => IRebalancer.d.ts} (95%)
 rename generated/abis/{IHarvester.js => IRebalancer.js} (97%)

diff --git a/contracts/helpers/BaseRebalancer.sol b/contracts/helpers/BaseRebalancer.sol
index 79d21ba..ca74d53 100644
--- a/contracts/helpers/BaseRebalancer.sol
+++ b/contracts/helpers/BaseRebalancer.sol
@@ -6,7 +6,7 @@ import { AccessManaged } from "../utils/AccessManaged.sol";
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import { IParallelizer } from "contracts/interfaces/IParallelizer.sol";
 import { ITokenP } from "contracts/interfaces/ITokenP.sol";
-import "contracts/interfaces/IHarvester.sol";
+import "contracts/interfaces/IRebalancer.sol";
 
 import "../utils/Errors.sol";
 
@@ -32,7 +32,7 @@ struct YieldBearingParams {
 /// @dev Abstract contract for a rebalancer that aims at rebalancing a Parallelizer
 /// @dev This contract is an authorized fork of Angle's BaseRebalancer contract:
 /// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseRebalancer.sol
-abstract contract BaseRebalancer is IHarvester, AccessManaged {
+abstract contract BaseRebalancer is IRebalancer, AccessManaged {
   using SafeERC20 for IERC20;
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/contracts/interfaces/IHarvester.sol b/contracts/interfaces/IRebalancer.sol
similarity index 94%
rename from contracts/interfaces/IHarvester.sol
rename to contracts/interfaces/IRebalancer.sol
index 8264790..6991e60 100644
--- a/contracts/interfaces/IHarvester.sol
+++ b/contracts/interfaces/IRebalancer.sol
@@ -1,12 +1,12 @@
 // SPDX-License-Identifier: GPL-3.0
 pragma solidity 0.8.28;
 
-/// @title IHarvester
+/// @title IRebalancer
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
 /// @dev This interface is an authorized fork of Angle's `IHarvester` interface
 /// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol
-interface IHarvester {
+interface IRebalancer {
   function setYieldBearingAssetData(
     address yieldBearingAsset,
     address stablecoin,
diff --git a/deployments/avalanche/GenericHarvester_USDp.json b/deployments/avalanche/GenericHarvester_USDp.json
deleted file mode 100644
index 0507bdb..0000000
--- a/deployments/avalanche/GenericHarvester_USDp.json
+++ /dev/null
@@ -1,1190 +0,0 @@
-{
-  "address": "0x0d45b129dc868963025db79a9074ea9c9e32cae4",
-  "abi": [
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initialTokenTransferAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialSwapRouter",
-          "type": "address"
-        },
-        {
-          "internalType": "contract ITokenP",
-          "name": "definitivetokenP",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IParallelizer",
-          "name": "definitiveParallelizer",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialAuthority",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "definitiveFlashloan",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedInvalidAuthority",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        },
-        {
-          "internalType": "uint32",
-          "name": "delay",
-          "type": "uint32"
-        }
-      ],
-      "name": "AccessManagedRequiredDelay",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedUnauthorized",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "InvalidParam",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrusted",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrustedOrGuardian",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        }
-      ],
-      "name": "SafeERC20FailedOperation",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "SwapError",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAddress",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAmount",
-      "type": "error"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AuthorityUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "Recovered",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "SwapRouterUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "TokenTransferAddressUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "bool",
-          "name": "status",
-          "type": "bool"
-        }
-      ],
-      "name": "TrustedToggled",
-      "type": "event"
-    },
-    {
-      "inputs": [],
-      "name": "CALLBACK_SUCCESS",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "addBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "authority",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "budget",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "computeRebalanceAmount",
-      "outputs": [
-        {
-          "internalType": "uint8",
-          "name": "increase",
-          "type": "uint8"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "flashloan",
-      "outputs": [
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "scale",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "extraData",
-          "type": "bytes"
-        }
-      ],
-      "name": "harvest",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "isConsumingScheduledOp",
-      "outputs": [
-        {
-          "internalType": "bytes4",
-          "name": "",
-          "type": "bytes4"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "isTrusted",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "maxTokenSlippage",
-      "outputs": [
-        {
-          "internalType": "uint96",
-          "name": "",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initiator",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "fee",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "name": "onFlashLoan",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "parallelizer",
-      "outputs": [
-        {
-          "internalType": "contract IParallelizer",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "tokenAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountToRecover",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "recoverERC20",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "removeBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newAuthority",
-          "type": "address"
-        }
-      ],
-      "name": "setAuthority",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint96",
-          "name": "newMaxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setMaxSlippage",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "setSwapRouter",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        }
-      ],
-      "name": "setTargetExposure",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "setTokenTransferAddress",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setYieldBearingAssetData",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "swapRouter",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        }
-      ],
-      "name": "toggleTrusted",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenP",
-      "outputs": [
-        {
-          "internalType": "contract ITokenP",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenTransferAddress",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "updateLimitExposuresYieldAsset",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "yieldBearingData",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "contractName": "GenericHarvester",
-  "sourceName": "contracts/helpers/GenericHarvester.sol",
-  "bytecode": "0x60e080604052346101e95760c08161270c803803809161001f828561020f565b8339810103126101e95761003281610246565b9061003f60208201610246565b6040820151926001600160a01b038416918285036101e95760608401516001600160a01b03811681036101e95760a061007a60808701610246565b950151956001600160a01b038716958688036101e9575f80546001600160a01b0319166001600160a01b0390921691821790556040519081527f2f658b440c35314f52658ea8a740e05b284cdc84dc9ae01e891f21b8933e7cad90602090a160a052608052600480546001600160a01b039283166001600160a01b0319918216179091556005805493909216921691909117905581156102005760446020925f9460c052604051948593849263095ea7b360e01b84526004840152811960248401525af180156101f5576101b9575b6040516124b1908161025b823960805181818161027601528181610ce601528181610e1e01528181611cd70152612069015260a0518181816103bf0152818161066c01528181610e4b015281816115790152611600015260c05181818161040701528181610d5b01526115bd0152f35b6020813d6020116101ed575b816101d26020938361020f565b810103126101e95751801515036101e9575f610149565b5f80fd5b3d91506101c5565b6040513d5f823e3d90fd5b63d92e233d60e01b5f5260045ffd5b601f909101601f19168101906001600160401b0382119082101761023257604052565b634e487b7160e01b5f52604160045260245ffd5b51906001600160a01b03821682036101e95756fe60806040526004361015610011575f80fd5b5f5f3560e01c80630dd3932d1461166a57806313047520146116245780631978a5ed146115e15780631b89b61a1461159e578063212c8fb1146114e557806323e30c8b14610d0a57806335b37d1a14610cc75780634127365714610c455780635a7cb38f14610c1f578063641bd50314610b6d5780637a9e5e4b14610a9f5780637ee8434914610a0e5780638195001d146109ed5780638237e538146109b35780638fb360371461094057806396d64879146109035780639ae784861461082e578063b51609b4146107a7578063bf7e214f14610782578063c31c9c071461075c578063c5e6d5ea146106cb578063c9c6667414610693578063d2d0ec101461062a578063da94e205146105b1578063e234b903146105025763edf0ef0314610138575f80fd5b346104ae5760603660031901126104ae576101516118c0565b60243560443567ffffffffffffffff81116104ae576101749036906004016118ec565b9290633b9aca0083116104da578161018d600293611a33565b6001600160a01b03811690815f5283602052633b9aca0061022c61022460405f206bffffffffffffffffffffffff6040519889926101ca84611972565b67ffffffffffffffff81546001600160a01b038116865260a01c16602085015267ffffffffffffffff60018201548181166040870152818160401c16606087015260801c1660808501520154169460a08201958652611cca565b979097611a79565b049586156104b2578301926040818503126104ae5780359360028510156104ae57602082013567ffffffffffffffff81116104ae5761026b92016119e0565b936001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016803b156104ae575f80916024604051809481937f1cb44dfc0000000000000000000000000000000000000000000000000000000083528960048401525af1610492575b506001600160a01b036bffffffffffffffffffffffff915116915116633b9aca00036bffffffffffffffffffffffff811161047e5760ff946103fa97946103849460209894633b9aca0061033e6bffffffffffffffffffffffff61037697168a611a79565b0491604051998a97338d8a01521660408801526060870152608086015260a085015260c084015260e0808401526101008301906122a3565b03601f1981018452836119a2565b60405193849283927f5cffe9de0000000000000000000000000000000000000000000000000000000084523060048501526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016602485015260448401526080606484015260848301906122a3565b0381856001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000165af1801561047357610437575080f35b6020813d60201161046b575b81610450602093836119a2565b810103126104675751801515036104645780f35b80fd5b5080fd5b3d9150610443565b6040513d84823e3d90fd5b602488634e487b7160e01b81526011600452fd5b61049f9198505f906119a2565b5f966001600160a01b036102d9565b5f80fd5b7f1f2a2005000000000000000000000000000000000000000000000000000000005f5260045ffd5b7fd2529034000000000000000000000000000000000000000000000000000000005f5260045ffd5b346104ae5760203660031901126104ae576001600160a01b036105236118c0565b610536336105313633611a8c565b61191a565b168015610589576020817ffd238617dbf7bc2e2e9c11b00a61a76432989bf0d6ca3a5aa34381a8752db4039273ffffffffffffffffffffffffffffffffffffffff196005541617600555604051908152a1005b7fd92e233d000000000000000000000000000000000000000000000000000000005f5260045ffd5b346104ae5760403660031901126104ae576105ca6118c0565b602435906bffffffffffffffffffffffff82168092036104ae576105f2336105313633611a8c565b633b9aca0082116104da576001600160a01b03165f52600160205260405f20906bffffffffffffffffffffffff198254161790555f80f35b346104ae5760403660031901126104ae576106916004356106496118d6565b335f52600660205260405f20610660838254611a26565b90556001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001661224c565b005b346104ae5760203660031901126104ae576001600160a01b036106b46118c0565b165f526006602052602060405f2054604051908152f35b346104ae5760203660031901126104ae576001600160a01b036106ec6118c0565b165f52600260205260c060405f2080549067ffffffffffffffff6bffffffffffffffffffffffff60026001840154930154169181604051946001600160a01b038116865260a01c1660208501528181166040850152818160401c16606085015260801c16608083015260a0820152f35b346104ae575f3660031901126104ae5760206001600160a01b0360045416604051908152f35b346104ae575f3660031901126104ae5760206001600160a01b035f5416604051908152f35b346104ae5760603660031901126104ae576107c06118c0565b6024356044356001600160a01b0381168082036104ae577fb197f0a554c4d7840105e6ae65f0e275e9e8605a969dffa8caa7f1f118a2e1f560606106919561080c336105313633611a8c565b6001600160a01b036040519116938482528660208301526040820152a161224c565b346104ae5760403660031901126104ae576108476118c0565b60243567ffffffffffffffff811681036104ae57335f52600360205260ff60405f20541615806108f2575b6108ca576001600160a01b0361069192165f52600260205260405f20907fffffffff0000000000000000ffffffffffffffffffffffffffffffffffffffff67ffffffffffffffff60a01b83549260a01b169116179055565b7f0dcc030f000000000000000000000000000000000000000000000000000000005f5260045ffd5b506108fd3633611a8c565b15610872565b346104ae5760203660031901126104ae576001600160a01b036109246118c0565b165f526003602052602060ff60405f2054166040519015158152f35b346104ae575f3660031901126104ae575f5460a01c60ff16156109ab5760207f8fb36037000000000000000000000000000000000000000000000000000000005b7fffffffff0000000000000000000000000000000000000000000000000000000060405191168152f35b60205f610981565b346104ae575f3660031901126104ae5760206040517f439148f0bbc682ca079e46d6e2c2f0c1e3b820f1a291b069d8882abf8cf18dd98152f35b346104ae5760203660031901126104ae57610691610a096118c0565b611a33565b346104ae5760203660031901126104ae576001600160a01b03610a2f6118c0565b610a3d336105313633611a8c565b16805f5260036020527f7628ea5f6112a16b36a8239aa208395a8e8f221688cfb3a5461faffb9700abcd604060ff815f20541681519084825215156020820152a15f908152600360205260409020805460ff818116151660ff19909116179055005b346104ae5760203660031901126104ae57610ab86118c0565b5f54906001600160a01b0382163303610b5b57803b15610b265773ffffffffffffffffffffffffffffffffffffffff197f2f658b440c35314f52658ea8a740e05b284cdc84dc9ae01e891f21b8933e7cad926001600160a01b036020931691829116175f55604051908152a1005b6001600160a01b03907fc2f31e5e000000000000000000000000000000000000000000000000000000005f521660045260245ffd5b62d1953b60e31b5f523360045260245ffd5b346104ae5760203660031901126104ae576040610c10610b8b6118c0565b6001600160a01b0381165f526002602052825f20906bffffffffffffffffffffffff6002855193610bbb85611972565b67ffffffffffffffff81546001600160a01b038116875260a01c16602086015267ffffffffffffffff60018201548181168988015281818a1c16606088015260801c16608086015201541660a0830152611cca565b60ff8351921682526020820152f35b346104ae575f3660031901126104ae5760206001600160a01b0360055416604051908152f35b346104ae5760203660031901126104ae576001600160a01b03610c666118c0565b610c74336105313633611a8c565b168015610589576020817f36db479a3b4d3672bd6f5fca4484283f60b5ac70647b1ceec13ecbb1d030a2df9273ffffffffffffffffffffffffffffffffffffffff196004541617600455604051908152a1005b346104ae575f3660031901126104ae5760206040516001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000168152f35b346104ae5760a03660031901126104ae57610d236118c0565b610d2b6118d6565b5060443560843567ffffffffffffffff81116104ae57610d4f9036906004016118ec565b90926001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000163314908115916114d1575b5080156114c6575b61149e5782019060e0838303126104ae57610da88361195e565b92610db56040820161195e565b610dc16060830161195e565b9360a08301359060028210156104ae5760c08401359067ffffffffffffffff82116104ae57610dfc6001600160a01b039291839287016119e0565b9616921694600160208501351495865f146114985792915b6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169687916001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001694604051926301db50ff60e51b84528960048501525f602485015286604485015260208460c4815f6001600160a01b038716998a60648401523060848401524260a48401525af19384156110c9575f94611464575b505f92600181036112c357505050506001600160a01b03851690604051936370a0823160e01b8552306004860152602085602481865afa9485156110c9575f9561128f575b50604093845192610f1686856119a2565b60018452601f1986019182366020870137610f3085612029565b52855192610f3e87856119a2565b600184525f5b83811061127e5750610f5584612029565b52610f5f83612029565b50855191610f6d87846119a2565b60018352366020840137610f8082612029565b528251925f5b84811061111c57505050505060206024918351928380926370a0823160e01b82523060048301525afa91821561111357505f916110d4575b5060809660c4936001600160a01b03610fdc60209897955f95611a26565b945b610fe9868583611c29565b6040519a8b9889976301db50ff60e51b895260048901520135602487015216604485015260648401523060848401524260a48401525af19182156110c9575f92611095575b50818111611061575b60206040517f439148f0bbc682ca079e46d6e2c2f0c1e3b820f1a291b069d8882abf8cf18dd98152f35b6001600160a01b039161107391611a26565b91165f52600660205261108b60405f20918254611a26565b9055808080611037565b9091506020813d6020116110c1575b816110b1602093836119a2565b810103126104ae5751908361102e565b3d91506110a4565b6040513d5f823e3d90fd5b905060209493919294813d60201161110b575b816110f4602093836119a2565b810103126104ae5751929390929091906080610fbe565b3d91506110e7565b513d5f823e3d90fd5b6001600160a01b0361112e828461204a565b51166001600160a01b036005541690611147838661204a565b518951636eb1769f60e11b81523060048201526001600160a01b03841660248201529290602084604481865afa938415611274575f94611241575b50808410611225575b505050505f8061119b838761204a565b516001600160a01b036004541682602083519301915af13d1561121d573d906111c3826119c4565b916111d08a5193846119a2565b82523d5f602084013e5b156111e85750600101610f86565b80519081611218577f7c3eb9ca000000000000000000000000000000000000000000000000000000005f5260045ffd5b602001fd5b6060906111da565b6112389361123291611a26565b91612334565b8e80808061118b565b9093506020813d821161126c575b8161125c602093836119a2565b810103126104ae5751925f611182565b3d915061124f565b8b513d5f823e3d90fd5b806060602080938801015201610f44565b9094506020813d6020116112bb575b816112ab602093836119a2565b810103126104ae5751938b610f05565b3d915061129e565b9091939492989a979550156112f0575b50505050925f6080969360c4936001600160a01b03602097610fde565b9396509192869290156113ba5750611309918391611c29565b604051907f6e553f6500000000000000000000000000000000000000000000000000000000825260048201523060248201526020816044815f6001600160a01b0389165af19081156110c9575f91611380575b50925f6080969360c4936001600160a01b036020975b9750829699508195506112d3565b95929390506020863d6020116113b2575b8161139e602093836119a2565b810103126104ae579451919492915f61135c565b3d9150611391565b90506020915060645f9360405194859384927fba08765200000000000000000000000000000000000000000000000000000000845260048401523060248401523060448401525af19081156110c9575f9161142a575b50925f6080969360c4936001600160a01b03602097611372565b95929390506020863d60201161145c575b81611448602093836119a2565b810103126104ae579451919492915f611410565b3d915061143b565b9093506020813d602011611490575b81611480602093836119a2565b810103126104ae5751928c610ec0565b3d9150611473565b91610e14565b7fc22a648e000000000000000000000000000000000000000000000000000000005f5260045ffd5b506064351515610d8e565b6001600160a01b0316301415905084610d86565b346104ae5760403660031901126104ae576106916004356001600160a01b0361150c6118d6565b165f52600660205260405f2061152382825461193d565b9055604051907f23b872dd00000000000000000000000000000000000000000000000000000000602083015233602483015230604483015260648201526064815261156f6084826119a2565b6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000166122c7565b346104ae575f3660031901126104ae5760206040516001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000168152f35b346104ae575f3660031901126104ae5760206040516001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000168152f35b346104ae5760203660031901126104ae576001600160a01b036116456118c0565b165f52600160205260206bffffffffffffffffffffffff60405f205416604051908152f35b346104ae5760e03660031901126104ae576116836118c0565b61168b6118d6565b6044359167ffffffffffffffff8316918284036104ae576064359267ffffffffffffffff8416918285036104ae576084359567ffffffffffffffff87168097036104ae5760a4359467ffffffffffffffff8616908187036104ae5760c435906bffffffffffffffffffffffff82168092036104ae576001600160a01b0390611717336105313633611a8c565b165f526002602052633b9aca0060405f20956001600160a01b03861673ffffffffffffffffffffffffffffffffffffffff1988541617875510156104da57633b9aca008110156104da576117a460019386907fffffffff0000000000000000ffffffffffffffffffffffffffffffffffffffff67ffffffffffffffff60a01b83549260a01b169116179055565b828501967fffffffffffffffff0000000000000000ffffffffffffffffffffffffffffffff77ffffffffffffffff0000000000000000000000000000000089549260801b16911617875560028501906bffffffffffffffffffffffff19825416179055145f1461187857505083633b9aca0081109182159261186d575b50506104da576106919267ffffffffffffffff19825416178155906fffffffffffffffff0000000000000000196fffffffffffffffff000000000000000083549260401b169116179055565b101590508385611821565b929150925061069193507002000000000000000000000000000000007fffffffffffffffff0000000000000000ffffffffffffffffffffffffffffffff82541617905561205e565b600435906001600160a01b03821682036104ae57565b602435906001600160a01b03821682036104ae57565b9181601f840112156104ae5782359167ffffffffffffffff83116104ae57602083818601950101116104ae57565b156119225750565b6001600160a01b039062d1953b60e31b5f521660045260245ffd5b9190820180921161194a57565b634e487b7160e01b5f52601160045260245ffd5b35906001600160a01b03821682036104ae57565b60c0810190811067ffffffffffffffff82111761198e57604052565b634e487b7160e01b5f52604160045260245ffd5b90601f8019910116810190811067ffffffffffffffff82111761198e57604052565b67ffffffffffffffff811161198e57601f01601f191660200190565b81601f820112156104ae578035906119f7826119c4565b92611a0560405194856119a2565b828452602083830101116104ae57815f926020809301838601378301015290565b9190820391821161194a57565b6001600160a01b03165f52600260205260405f20600267ffffffffffffffff600183015460801c1614611a635750565b806001600160a01b03611a7792541661205e565b565b8181029291811591840414171561194a57565b905f915f54916001600160a01b03831692816004116104ae575f5f9060405f8151966001600160a01b0360208901917fb700961300000000000000000000000000000000000000000000000000000000835216978860248201523060448201527fffffffff00000000000000000000000000000000000000000000000000000000833516606482015260648152611b246084826119a2565b828052826020525190895afa611c16575b15611b46575b505050505050600190565b63ffffffff1615611c0d5760ff60a01b191674010000000000000000000000000000000000000000175f55823b156104ae576064925f92836040519586809581947f94c7d7ee0000000000000000000000000000000000000000000000000000000083526004830152604060248301528060448301528084848401378181018301849052601f01601f191681010301925af180156110c957611bfa575b5060ff60a01b1981541690555f8080808080611b3b565b611c0691505f906119a2565b5f5f611be3565b50505050505f90565b50505f516020518060201c150290611b35565b604051636eb1769f60e11b81523060048201526001600160a01b038381166024830152909391169190602084604481865afa9384156110c9575f94611c80575b508310611c7557505050565b611a77921991612334565b9093506020813d602011611cac575b81611c9c602093836119a2565b810103126104ae5751925f611c69565b3d9150611c8f565b91908260409103126104ae576020825192015190565b915f926001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016906001600160a01b0360405191634a71aecf60e11b8352166004820152604081602481855afa9081156110c9575f905f92611ee6575b5060406001600160a01b038651166024825180968193634a71aecf60e11b835260048301525afa9283156110c9575f93611eb4575b50611d7b8267ffffffffffffffff602088015116611a79565b633b9aca008202828104633b9aca00148315171561194a57811015611e2b576040611dba611dc39493633b9aca0067ffffffffffffffff940490611a26565b96015116611a79565b633b9aca008202828104633b9aca00148315171561194a57811015611de957505f925050565b611df3848361193d565b633b9aca00810290808204633b9aca00149015171561194a578110611e16575050565b611e28929350633b9aca009004611a26565b90565b95509067ffffffffffffffff6060611dba611e4e94633b9aca0060019a04611a26565b633b9aca008202828104633b9aca00148315171561194a5781811015611e7657505f93505050565b633b9aca008502858104633b9aca00148615171561194a57611e98908361193d565b11611ea1575050565b611e28929350633b9aca00900490611a26565b611ed791935060403d604011611edf575b611ecf81836119a2565b810190611cb4565b50915f611d62565b503d611ec5565b9050611f01915060403d604011611edf57611ecf81836119a2565b905f611d2d565b67ffffffffffffffff811161198e5760051b60200190565b91906040838203126104ae57825167ffffffffffffffff81116104ae57830181601f820112156104ae578051611f5581611f08565b91611f6360405193846119a2565b81835260208084019260051b820101908482116104ae57602001915b818310612008575050509260208101519067ffffffffffffffff82116104ae57019080601f830112156104ae57815190611fb882611f08565b92611fc660405194856119a2565b82845260208085019360051b8201019182116104ae57602001915b818310611fee5750505090565b82518060070b81036104ae57815260209283019201611fe1565b825167ffffffffffffffff811681036104ae57815260209283019201611f7f565b8051156120365760200190565b634e487b7160e01b5f52603260045260245ffd5b80518210156120365760209160051b010190565b906001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016916001600160a01b03604051917fb85780bc000000000000000000000000000000000000000000000000000000008352168060048301525f82602481875afa9182156110c9575f9261222f575b508151600181116121e9575060018301805467ffffffffffffffff1916633b9aca001790555f91505b6024604051809581937f847da7be00000000000000000000000000000000000000000000000000000000835260048301525afa9182156110c9575f926121c4575b508151916001831161216a575060010180546fffffffffffffffff00000000000000001916905550565b600119830192831161194a5767ffffffffffffffff61218e611a779460019361204a565b51169101906fffffffffffffffff0000000000000000196fffffffffffffffff000000000000000083549260401b169116179055565b6121e19192503d805f833e6121d981836119a2565b810190611f20565b50905f612140565b600119810190811161194a5761220967ffffffffffffffff915f9461204a565b511667ffffffffffffffff60018501911667ffffffffffffffff198254161790556120ff565b6122449192503d805f833e6121d981836119a2565b50905f6120d6565b6040517fa9059cbb0000000000000000000000000000000000000000000000000000000060208201526001600160a01b0390921660248301526044820192909252611a779161229e8260648101610376565b6122c7565b805180835260209291819084018484015e5f828201840152601f01601f1916010190565b905f602091828151910182855af1156110c9575f513d61232b57506001600160a01b0381163b155b6122f65750565b6001600160a01b03907f5274afe7000000000000000000000000000000000000000000000000000000005f521660045260245ffd5b600114156122ef565b604051636eb1769f60e11b81523060048201526001600160a01b038381166024830152929392821692602082604481875afa80156110c9575f90612447575b61237d925061193d565b9160205f604051946123c8866123ba8582019363095ea7b360e01b85528a60248401602090939291936001600160a01b0360408201951681520152565b03601f1981018852876119a2565b85519082865af1903d5f519083612428575b505050156123e757505050565b61229e611a77936001600160a01b036040519163095ea7b360e01b60208401521660248201525f6044820152604481526124226064826119a2565b826122c7565b9192509061243d57503b15155b5f80806123da565b6001915014612435565b506020823d602011612473575b81612461602093836119a2565b810103126104ae5761237d9151612373565b3d915061245456fea2646970667358221220c91ca8ea8899ca08b3839156df940b48fa1be932a747ba5243a6a03e6a682f0564736f6c634300081c0033",
-  "deployedBytecode": "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",
-  "linkReferences": {},
-  "deployedLinkReferences": {},
-  "immutableReferences": {
-    "7707": [
-      {
-        "length": 32,
-        "start": 630
-      },
-      {
-        "length": 32,
-        "start": 3302
-      },
-      {
-        "length": 32,
-        "start": 3614
-      },
-      {
-        "length": 32,
-        "start": 7383
-      },
-      {
-        "length": 32,
-        "start": 8297
-      }
-    ],
-    "7711": [
-      {
-        "length": 32,
-        "start": 959
-      },
-      {
-        "length": 32,
-        "start": 1644
-      },
-      {
-        "length": 32,
-        "start": 3659
-      },
-      {
-        "length": 32,
-        "start": 5497
-      },
-      {
-        "length": 32,
-        "start": 5632
-      }
-    ],
-    "8438": [
-      {
-        "length": 32,
-        "start": 1031
-      },
-      {
-        "length": 32,
-        "start": 3419
-      },
-      {
-        "length": 32,
-        "start": 5565
-      }
-    ]
-  },
-  "inputSourceName": "project/contracts/helpers/GenericHarvester.sol",
-  "devdoc": {
-    "author": "Cooper Labs",
-    "custom:contact": "security@cooperlabs.xyz",
-    "details": "Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
-    "errors": {
-      "SafeERC20FailedOperation(address)": [
-        {
-          "details": "An operation with an ERC-20 token failed."
-        }
-      ]
-    },
-    "events": {
-      "AuthorityUpdated(address)": {
-        "details": "Authority that manages this contract was updated."
-      }
-    },
-    "kind": "dev",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to add to the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "authority()": {
-        "details": "Returns the current authority."
-      },
-      "computeRebalanceAmount(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        },
-        "returns": {
-          "amount": "amount to be rebalanced",
-          "increase": "whether the exposure should be increased"
-        }
-      },
-      "harvest(address,uint256,bytes)": {
-        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage"
-      },
-      "isConsumingScheduledOp()": {
-        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
-      },
-      "onFlashLoan(address,address,uint256,uint256,bytes)": {
-        "details": "Receive a flash loan.",
-        "params": {
-          "amount": "The amount of tokens lent.",
-          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
-          "fee": "The additional amount of tokens to repay.",
-          "initiator": "The initiator of the loan.",
-          "token": "The loan currency."
-        },
-        "returns": {
-          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
-        }
-      },
-      "recoverERC20(address,uint256,address)": {
-        "params": {
-          "amountToRecover": "amount to recover",
-          "to": "address to send the recovered tokens",
-          "tokenAddress": "address of the token to recover"
-        }
-      },
-      "removeBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to remove from the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "setAuthority(address)": {
-        "details": "Transfers control to a new authority. The caller must be the current authority."
-      },
-      "setMaxSlippage(address,uint96)": {
-        "params": {
-          "newMaxSlippage": "new max allowed slippage"
-        }
-      },
-      "setSwapRouter(address)": {
-        "params": {
-          "newSwapRouter": "address of the swap router"
-        }
-      },
-      "setTargetExposure(address,uint64)": {
-        "params": {
-          "targetExposure": "target exposure to the yield bearing asset used",
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      },
-      "setTokenTransferAddress(address)": {
-        "params": {
-          "newTokenTransferAddress": "address of the token transfer contract"
-        }
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "params": {
-          "asset": "address of the asset",
-          "maxExposure": "maximum exposure within the Parallelizer to the asset",
-          "minExposure": "minimum exposure within the Parallelizer to the asset",
-          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
-          "targetExposure": "target exposure to the yieldBearingAsset asset used",
-          "yieldBearingAsset": "address of the yieldBearingAsset"
-        }
-      },
-      "toggleTrusted(address)": {
-        "params": {
-          "trusted": "address to toggle the trusted status"
-        }
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      }
-    },
-    "title": "GenericHarvester",
-    "version": 1
-  },
-  "evm": {
-    "gasEstimates": {
-      "creation": {
-        "codeDepositCost": "1878600",
-        "executionCost": "infinite",
-        "totalCost": "infinite"
-      },
-      "external": {
-        "CALLBACK_SUCCESS()": "433",
-        "addBudget(uint256,address)": "infinite",
-        "authority()": "2663",
-        "budget(address)": "2862",
-        "computeRebalanceAmount(address)": "infinite",
-        "flashloan()": "infinite",
-        "harvest(address,uint256,bytes)": "infinite",
-        "isConsumingScheduledOp()": "2606",
-        "isTrusted(address)": "2742",
-        "maxTokenSlippage(address)": "2428",
-        "onFlashLoan(address,address,uint256,uint256,bytes)": "infinite",
-        "parallelizer()": "infinite",
-        "recoverERC20(address,uint256,address)": "infinite",
-        "removeBudget(uint256,address)": "infinite",
-        "setAuthority(address)": "28360",
-        "setMaxSlippage(address,uint96)": "infinite",
-        "setSwapRouter(address)": "infinite",
-        "setTargetExposure(address,uint64)": "infinite",
-        "setTokenTransferAddress(address)": "infinite",
-        "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": "infinite",
-        "swapRouter()": "2686",
-        "toggleTrusted(address)": "infinite",
-        "tokenP()": "infinite",
-        "tokenTransferAddress()": "2444",
-        "updateLimitExposuresYieldAsset(address)": "infinite",
-        "yieldBearingData(address)": "7217"
-      },
-      "internal": {
-        "_adjustYieldExposure(uint256,uint8,address,address,uint256,enum SwapType,bytes memory)": "infinite",
-        "_swapToTokenOut(uint256,address,address,uint256,enum SwapType,bytes memory)": "infinite",
-        "_swapToTokenOutSwap(address,address,uint256,bytes memory)": "infinite",
-        "_swapToTokenOutVault(uint256,address,address,uint256)": "infinite"
-      }
-    }
-  },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"maxTokenSlippage\",\"outputs\":[{\"internalType\":\"uint96\",\"name\":\"\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint96\",\"name\":\"newMaxSlippage\",\"type\":\"uint96\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"Receive a flash loan.\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint96)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericHarvester\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"maxTokenSlippage(address)\":{\"notice\":\"Max slippage when dealing with the Parallelizer\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"setMaxSlippage(address,uint96)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/helpers/GenericHarvester.sol\":\"GenericHarvester\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"],\"viaIR\":true},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0x1121e070554cffc6d536f658332a1a3d65fb2ea5573cd774f4ecbd02a2fcf4b7\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x4e4b982b56b50290dd1dcaa2fef1178b1574dfc7c0f0a8ef9cb68a207d72582e\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity >=0.5.0;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x218d708e7d8df417db24a497727eefb7772e61c7cde3886fc42bbcb6aafa6947\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/helpers/BaseHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IHarvester.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer\\n  uint96 maxSlippage;\\n}\\n\\n/// @title BaseHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a harvester that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseHarvester is IHarvester, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Max slippage when dealing with the Parallelizer\\n  mapping(address => uint96) public maxTokenSlippage;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage > 1e9) revert InvalidParam();\\n    maxTokenSlippage[yieldBearingAsset] = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x82e2ae57997043160d7529488b34591c710cd74e267213b61009daa96e9eeaaf\",\"license\":\"GPL-3.0\"},\"project/contracts/helpers/GenericHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseHarvester, YieldBearingParams } from \\\"./BaseHarvester.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for anyone to permissionlessly adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseHarvester(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this) || fee != 0) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n\\n    // Swap to tokenIn\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x604c4f9c755b2eb704dc15ba59046201c0258134ef2fbe15a529c510c68cb40a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaa9eba6ee7770d6146fedbfef07ad10ff09524692319ca0cc32abfa64a2b597b\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IHarvester {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0d4e8fee737f4f747060a3c5044c8cb2f153faa228ad37a661a659ca62aab055\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IParallelizer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IParallelizer.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper\\n{ }\\n\",\"keccak256\":\"0x8bd964110c6a122bdb6cf58a194a97c894900237ebd7f3b11e2f43c6ee56ae7c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0xb3522ee0380b321c64d02bf2db2acb658d8b314b811dd54b6a718d6708b5fb21\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Changes the pause status for mint or burn transactions for `collateral`\\n  function togglePause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xc3fb2012e7c2f97ae93b12276afc4293aaeb97a6fe4d60109acaa94ef6945575\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0x47e4b2742a51b82b9df72fb681335affe8519f4114fb540cd29d8f48ed182ffd\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType;\\n}\\n// Whether an address is whitelisted for a specific whitelist type\\n\",\"keccak256\":\"0x3f4313dd110dbe390038320b2d3cf24dcbe9b75cd9573e7f048f7233c02dd227\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror Paused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\n\",\"keccak256\":\"0x1e2f6812ef78e948e5155d32213b52afff8c0ba5463d18bee10694efbf886130\",\"license\":\"BUSL-1.1\"},\"project/libs/helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"}},\"version\":1}",
-  "storageLayout": {
-    "storage": [
-      {
-        "astId": 22488,
-        "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_authority",
-        "offset": 0,
-        "slot": "0",
-        "type": "t_address"
-      },
-      {
-        "astId": 22490,
-        "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_consumingSchedule",
-        "offset": 20,
-        "slot": "0",
-        "type": "t_bool"
-      },
-      {
-        "astId": 7716,
-        "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "maxTokenSlippage",
-        "offset": 0,
-        "slot": "1",
-        "type": "t_mapping(t_address,t_uint96)"
-      },
-      {
-        "astId": 7722,
-        "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "yieldBearingData",
-        "offset": 0,
-        "slot": "2",
-        "type": "t_mapping(t_address,t_struct(YieldBearingParams)7657_storage)"
-      },
-      {
-        "astId": 7727,
-        "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "isTrusted",
-        "offset": 0,
-        "slot": "3",
-        "type": "t_mapping(t_address,t_bool)"
-      },
-      {
-        "astId": 23206,
-        "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "swapRouter",
-        "offset": 0,
-        "slot": "4",
-        "type": "t_address"
-      },
-      {
-        "astId": 23209,
-        "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "tokenTransferAddress",
-        "offset": 0,
-        "slot": "5",
-        "type": "t_address"
-      },
-      {
-        "astId": 8443,
-        "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "budget",
-        "offset": 0,
-        "slot": "6",
-        "type": "t_mapping(t_address,t_uint256)"
-      }
-    ],
-    "types": {
-      "t_address": {
-        "encoding": "inplace",
-        "label": "address",
-        "numberOfBytes": "20"
-      },
-      "t_bool": {
-        "encoding": "inplace",
-        "label": "bool",
-        "numberOfBytes": "1"
-      },
-      "t_mapping(t_address,t_bool)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => bool)",
-        "numberOfBytes": "32",
-        "value": "t_bool"
-      },
-      "t_mapping(t_address,t_struct(YieldBearingParams)7657_storage)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => struct YieldBearingParams)",
-        "numberOfBytes": "32",
-        "value": "t_struct(YieldBearingParams)7657_storage"
-      },
-      "t_mapping(t_address,t_uint256)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint256)",
-        "numberOfBytes": "32",
-        "value": "t_uint256"
-      },
-      "t_mapping(t_address,t_uint96)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint96)",
-        "numberOfBytes": "32",
-        "value": "t_uint96"
-      },
-      "t_struct(YieldBearingParams)7657_storage": {
-        "encoding": "inplace",
-        "label": "struct YieldBearingParams",
-        "members": [
-          {
-            "astId": 7646,
-            "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "asset",
-            "offset": 0,
-            "slot": "0",
-            "type": "t_address"
-          },
-          {
-            "astId": 7648,
-            "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "targetExposure",
-            "offset": 20,
-            "slot": "0",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 7650,
-            "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxExposure",
-            "offset": 0,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 7652,
-            "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "minExposure",
-            "offset": 8,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 7654,
-            "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "overrideExposures",
-            "offset": 16,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 7656,
-            "contract": "project/contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxSlippage",
-            "offset": 0,
-            "slot": "2",
-            "type": "t_uint96"
-          }
-        ],
-        "numberOfBytes": "96"
-      },
-      "t_uint256": {
-        "encoding": "inplace",
-        "label": "uint256",
-        "numberOfBytes": "32"
-      },
-      "t_uint64": {
-        "encoding": "inplace",
-        "label": "uint64",
-        "numberOfBytes": "8"
-      },
-      "t_uint96": {
-        "encoding": "inplace",
-        "label": "uint96",
-        "numberOfBytes": "12"
-      }
-    }
-  },
-  "userdoc": {
-    "events": {
-      "SwapRouterUpdated(address)": {
-        "notice": "Event emitted when the swap router is updated"
-      },
-      "TokenTransferAddressUpdated(address)": {
-        "notice": "Event emitted when the token proxy is updated"
-      }
-    },
-    "kind": "user",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "notice": "Add budget to be spent by the receiver during the flashloan"
-      },
-      "budget(address)": {
-        "notice": "Budget of tokenP available for each users"
-      },
-      "computeRebalanceAmount(address)": {
-        "notice": "Compute the amount needed to rebalance the Parallelizer"
-      },
-      "flashloan()": {
-        "notice": "Parallel stablecoin flashloan contract"
-      },
-      "harvest(address,uint256,bytes)": {
-        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
-      },
-      "isTrusted(address)": {
-        "notice": "trusted addresses that can update target exposure and do others non critical operations"
-      },
-      "maxTokenSlippage(address)": {
-        "notice": "Max slippage when dealing with the Parallelizer"
-      },
-      "parallelizer()": {
-        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
-      },
-      "recoverERC20(address,uint256,address)": {
-        "notice": "Recover ERC20 tokens"
-      },
-      "removeBudget(uint256,address)": {
-        "notice": "Remove budget from the owner and send it to the receiver"
-      },
-      "setMaxSlippage(address,uint96)": {
-        "notice": "Set the max allowed slippage"
-      },
-      "setSwapRouter(address)": {
-        "notice": "Set the swap router"
-      },
-      "setTargetExposure(address,uint64)": {
-        "notice": "Set the target exposure of a yield bearing asset"
-      },
-      "setTokenTransferAddress(address)": {
-        "notice": "Set the token transfer address"
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "notice": "Set the yieldBearingAsset data"
-      },
-      "swapRouter()": {
-        "notice": "address of the router/aggregator"
-      },
-      "toggleTrusted(address)": {
-        "notice": "Toggle the trusted status of an address"
-      },
-      "tokenP()": {
-        "notice": "TokenP handled by the `parallelizer` of interest"
-      },
-      "tokenTransferAddress()": {
-        "notice": "address to approve to transfer tokens to"
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
-      },
-      "yieldBearingData(address)": {
-        "notice": "Data associated to a yield bearing asset"
-      }
-    },
-    "version": 1
-  },
-  "argsData": "0x00000000000000000000000088de50b233052e4fb783d4f6db78cc34fea3e9fc00000000000000000000000088de50b233052e4fb783d4f6db78cc34fea3e9fc0000000000000000000000009ee1963f05553ef838604dd39403be21cef26aa400000000000000000000000041d58951cbd12d4ef49b0437897677bbf5547c80000000000000000000000000fd28f108e95f4d41daae9dbfff707d677985998e0000000000000000000000009e0dcf7a33bbde6689560c5c807dd2a3df991277",
-  "transaction": {
-    "hash": "0xf9fdb881ae9b14af38626a6adee579e13a3946b210c7409a354a6d8751eec211",
-    "nonce": "0x78",
-    "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
-  },
-  "receipt": {
-    "blockHash": "0x77da7b9248dabc067ce7019a829d0e178c0d3f299517d26e64d65280050d51a4",
-    "blockNumber": "0x4104093",
-    "transactionIndex": "0x7"
-  }
-}
\ No newline at end of file
diff --git a/deployments/base/GenericHarvester_USDp.json b/deployments/base/GenericHarvester_USDp.json
deleted file mode 100644
index 59dcfa2..0000000
--- a/deployments/base/GenericHarvester_USDp.json
+++ /dev/null
@@ -1,1124 +0,0 @@
-{
-  "address": "0xCa43eCFCDFBA1fED003649e946Ae6091646B410a",
-  "abi": [
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initialTokenTransferAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialSwapRouter",
-          "type": "address"
-        },
-        {
-          "internalType": "contract ITokenP",
-          "name": "definitivetokenP",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IParallelizer",
-          "name": "definitiveParallelizer",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialAuthority",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "definitiveFlashloan",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedInvalidAuthority",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        },
-        {
-          "internalType": "uint32",
-          "name": "delay",
-          "type": "uint32"
-        }
-      ],
-      "name": "AccessManagedRequiredDelay",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedUnauthorized",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "InvalidParam",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrusted",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrustedOrGuardian",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        }
-      ],
-      "name": "SafeERC20FailedOperation",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "SwapError",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAddress",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAmount",
-      "type": "error"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AuthorityUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "Recovered",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "SwapRouterUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "TokenTransferAddressUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "bool",
-          "name": "status",
-          "type": "bool"
-        }
-      ],
-      "name": "TrustedToggled",
-      "type": "event"
-    },
-    {
-      "inputs": [],
-      "name": "CALLBACK_SUCCESS",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "addBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "authority",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "budget",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "computeRebalanceAmount",
-      "outputs": [
-        {
-          "internalType": "uint8",
-          "name": "increase",
-          "type": "uint8"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "flashloan",
-      "outputs": [
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "scale",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "extraData",
-          "type": "bytes"
-        }
-      ],
-      "name": "harvest",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "isConsumingScheduledOp",
-      "outputs": [
-        {
-          "internalType": "bytes4",
-          "name": "",
-          "type": "bytes4"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "isTrusted",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "maxTokenSlippage",
-      "outputs": [
-        {
-          "internalType": "uint96",
-          "name": "",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initiator",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "fee",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "name": "onFlashLoan",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "parallelizer",
-      "outputs": [
-        {
-          "internalType": "contract IParallelizer",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "tokenAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountToRecover",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "recoverERC20",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "removeBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newAuthority",
-          "type": "address"
-        }
-      ],
-      "name": "setAuthority",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint96",
-          "name": "newMaxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setMaxSlippage",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "setSwapRouter",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        }
-      ],
-      "name": "setTargetExposure",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "setTokenTransferAddress",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setYieldBearingAssetData",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "swapRouter",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        }
-      ],
-      "name": "toggleTrusted",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenP",
-      "outputs": [
-        {
-          "internalType": "contract ITokenP",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenTransferAddress",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "updateLimitExposuresYieldAsset",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "yieldBearingData",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "transactionHash": "0x9a88645c33c969e68e41437d785b884db2c9e783597a09c2a7fd4f173749fcef",
-  "receipt": {
-    "to": null,
-    "from": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02",
-    "contractAddress": "0xCa43eCFCDFBA1fED003649e946Ae6091646B410a",
-    "transactionIndex": 51,
-    "gasUsed": "2210613",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000040000000000000200000000000000000000010000000000000000000000000200000000000000000000000100400000000000000000000000000000000000000000000100000100000000000000000000000000000000000000000000000000000000000000100000000000000000000000008000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000010000000010000000000000000008000000000004000000000000000000001000000010",
-    "blockHash": "0x1d4aa3216f7e53cae7dd2878a8a75262c1a2e0cf151a774a5bf9f18fcdfdb9de",
-    "transactionHash": "0x9a88645c33c969e68e41437d785b884db2c9e783597a09c2a7fd4f173749fcef",
-    "logs": [
-      {
-        "transactionIndex": 51,
-        "blockNumber": 31946047,
-        "transactionHash": "0x9a88645c33c969e68e41437d785b884db2c9e783597a09c2a7fd4f173749fcef",
-        "address": "0xCa43eCFCDFBA1fED003649e946Ae6091646B410a",
-        "topics": [
-          "0x2f658b440c35314f52658ea8a740e05b284cdc84dc9ae01e891f21b8933e7cad"
-        ],
-        "data": "0x0000000000000000000000000e4e7ca9d7b1e6293d0713efefb4bca010debf46",
-        "logIndex": 213,
-        "blockHash": "0x1d4aa3216f7e53cae7dd2878a8a75262c1a2e0cf151a774a5bf9f18fcdfdb9de"
-      },
-      {
-        "transactionIndex": 51,
-        "blockNumber": 31946047,
-        "transactionHash": "0x9a88645c33c969e68e41437d785b884db2c9e783597a09c2a7fd4f173749fcef",
-        "address": "0x76A9A0062ec6712b99B4f63bD2b4270185759dd5",
-        "topics": [
-          "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
-          "0x000000000000000000000000ca43ecfcdfba1fed003649e946ae6091646b410a",
-          "0x00000000000000000000000008417cdb7f52a5021bb4eb6e0deaf3f295c3f182"
-        ],
-        "data": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-        "logIndex": 214,
-        "blockHash": "0x1d4aa3216f7e53cae7dd2878a8a75262c1a2e0cf151a774a5bf9f18fcdfdb9de"
-      }
-    ],
-    "blockNumber": 31946047,
-    "cumulativeGasUsed": "17679273",
-    "status": 1,
-    "byzantium": true
-  },
-  "args": [
-    "0x19ceead7105607cd444f5ad10dd51356436095a1",
-    "0x19ceead7105607cd444f5ad10dd51356436095a1",
-    "0x76A9A0062ec6712b99B4f63bD2b4270185759dd5",
-    "0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD",
-    "0x0e4e7Ca9D7b1e6293D0713EFEfB4BCA010DeBF46",
-    "0x08417cdb7F52a5021bB4eb6E0deAf3f295c3f182"
-  ],
-  "numDeployments": 1,
-  "solcInputHash": "9e6800737641b3b015331b65b5c620c3",
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"maxTokenSlippage\",\"outputs\":[{\"internalType\":\"uint96\",\"name\":\"\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint96\",\"name\":\"newMaxSlippage\",\"type\":\"uint96\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"Receive a flash loan.\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint96)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericHarvester\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"maxTokenSlippage(address)\":{\"notice\":\"Max slippage when dealing with the Parallelizer\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"setMaxSlippage(address,uint96)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/helpers/GenericHarvester.sol\":\"GenericHarvester\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"},\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        (bool success, bytes memory data) = authority.staticcall(\\n            abi.encodeCall(IAuthority.canCall, (caller, target, selector))\\n        );\\n        if (success) {\\n            if (data.length >= 0x40) {\\n                (immediate, delay) = abi.decode(data, (bool, uint32));\\n            } else if (data.length >= 0x20) {\\n                immediate = abi.decode(data, (bool));\\n            }\\n        }\\n        return (immediate, delay);\\n    }\\n}\\n\",\"keccak256\":\"0xb3875997b0d8705e29aa20fee88e1dfef93df438794ae1ad8ba2eb016a4dd4e4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity ^0.8.20;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaba93d42cd70e1418782951132d97b31ddce5f50ad81090884b6d0e41caac9d6\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Time} from \\\"../../utils/types/Time.sol\\\";\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `immediate` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x9be2d08a326515805bc9cf6315b7953f8d1ebe88abf48c2d645fb1fa8211a0e2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAuthority.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x4cc0766bd7fb7b3bafb70afa2a93b6e313a0baec7a35ad1b57505be7861c1030\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x0b1459615b9b47c2a4eec8e72f23ccc601f1d711f679a1c06b3390459021a341\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x5d19ea24c555cf6a5dbafea9fac57887cc3e72154f3ee8e0a2bf67971811c14b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x4ea01544758fd2c7045961904686bfe232d2220a04ecaa2d6b08dac17827febf\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            if (c < a) return (false, 0);\\n            return (true, c);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b > a) return (false, 0);\\n            return (true, a - b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n            // benefit is lost if 'b' is also tested.\\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n            if (a == 0) return (true, 0);\\n            uint256 c = a * b;\\n            if (c / a != b) return (false, 0);\\n            return (true, c);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b == 0) return (false, 0);\\n            return (true, a / b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b == 0) return (false, 0);\\n            return (true, a % b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n            // variables such that product = prod1 * 2\\u00b2\\u2075\\u2076 + prod0.\\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\\n            uint256 prod1; // Most significant 256 bits of the product\\n            assembly {\\n                let mm := mulmod(x, y, not(0))\\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n            }\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (prod1 == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return prod0 / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= prod1) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [prod1 prod0].\\n            uint256 remainder;\\n            assembly {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                prod1 := sub(prod1, gt(remainder, prod0))\\n                prod0 := sub(prod0, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [prod1 prod0] by twos.\\n                prod0 := div(prod0, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from prod1 into prod0.\\n            prod0 |= prod1 * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and prod1\\n            // is no longer required.\\n            result = prod0 * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        uint256 exp;\\n        unchecked {\\n            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            result += SafeCast.toUint(value > 1);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        uint256 isGt;\\n        unchecked {\\n            isGt = SafeCast.toUint(value > (1 << 128) - 1);\\n            value >>= isGt * 128;\\n            result += isGt * 16;\\n\\n            isGt = SafeCast.toUint(value > (1 << 64) - 1);\\n            value >>= isGt * 64;\\n            result += isGt * 8;\\n\\n            isGt = SafeCast.toUint(value > (1 << 32) - 1);\\n            value >>= isGt * 32;\\n            result += isGt * 4;\\n\\n            isGt = SafeCast.toUint(value > (1 << 16) - 1);\\n            value >>= isGt * 16;\\n            result += isGt * 2;\\n\\n            result += SafeCast.toUint(value > (1 << 8) - 1);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0xa00be322d7db5786750ce0ac7e2f5b633ac30a5ed5fa1ced1e74acfc19acecea\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/types/Time.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/types/Time.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Math} from \\\"../math/Math.sol\\\";\\nimport {SafeCast} from \\\"../math/SafeCast.sol\\\";\\n\\n/**\\n * @dev This library provides helpers for manipulating time-related objects.\\n *\\n * It uses the following types:\\n * - `uint48` for timepoints\\n * - `uint32` for durations\\n *\\n * While the library doesn't provide specific types for timepoints and duration, it does provide:\\n * - a `Delay` type to represent duration that can be programmed to change value automatically at a given point\\n * - additional helper functions\\n */\\nlibrary Time {\\n    using Time for *;\\n\\n    /**\\n     * @dev Get the block timestamp as a Timepoint.\\n     */\\n    function timestamp() internal view returns (uint48) {\\n        return SafeCast.toUint48(block.timestamp);\\n    }\\n\\n    /**\\n     * @dev Get the block number as a Timepoint.\\n     */\\n    function blockNumber() internal view returns (uint48) {\\n        return SafeCast.toUint48(block.number);\\n    }\\n\\n    // ==================================================== Delay =====================================================\\n    /**\\n     * @dev A `Delay` is a uint32 duration that can be programmed to change value automatically at a given point in the\\n     * future. The \\\"effect\\\" timepoint describes when the transitions happens from the \\\"old\\\" value to the \\\"new\\\" value.\\n     * This allows updating the delay applied to some operation while keeping some guarantees.\\n     *\\n     * In particular, the {update} function guarantees that if the delay is reduced, the old delay still applies for\\n     * some time. For example if the delay is currently 7 days to do an upgrade, the admin should not be able to set\\n     * the delay to 0 and upgrade immediately. If the admin wants to reduce the delay, the old delay (7 days) should\\n     * still apply for some time.\\n     *\\n     *\\n     * The `Delay` type is 112 bits long, and packs the following:\\n     *\\n     * ```\\n     *   | [uint48]: effect date (timepoint)\\n     *   |           | [uint32]: value before (duration)\\n     *   \\u2193           \\u2193       \\u2193 [uint32]: value after (duration)\\n     * 0xAAAAAAAAAAAABBBBBBBBCCCCCCCC\\n     * ```\\n     *\\n     * NOTE: The {get} and {withUpdate} functions operate using timestamps. Block number based delays are not currently\\n     * supported.\\n     */\\n    type Delay is uint112;\\n\\n    /**\\n     * @dev Wrap a duration into a Delay to add the one-step \\\"update in the future\\\" feature\\n     */\\n    function toDelay(uint32 duration) internal pure returns (Delay) {\\n        return Delay.wrap(duration);\\n    }\\n\\n    /**\\n     * @dev Get the value at a given timepoint plus the pending value and effect timepoint if there is a scheduled\\n     * change after this timepoint. If the effect timepoint is 0, then the pending value should not be considered.\\n     */\\n    function _getFullAt(\\n        Delay self,\\n        uint48 timepoint\\n    ) private pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        (valueBefore, valueAfter, effect) = self.unpack();\\n        return effect <= timepoint ? (valueAfter, 0, 0) : (valueBefore, valueAfter, effect);\\n    }\\n\\n    /**\\n     * @dev Get the current value plus the pending value and effect timepoint if there is a scheduled change. If the\\n     * effect timepoint is 0, then the pending value should not be considered.\\n     */\\n    function getFull(Delay self) internal view returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        return _getFullAt(self, timestamp());\\n    }\\n\\n    /**\\n     * @dev Get the current value.\\n     */\\n    function get(Delay self) internal view returns (uint32) {\\n        (uint32 delay, , ) = self.getFull();\\n        return delay;\\n    }\\n\\n    /**\\n     * @dev Update a Delay object so that it takes a new duration after a timepoint that is automatically computed to\\n     * enforce the old delay at the moment of the update. Returns the updated Delay object and the timestamp when the\\n     * new delay becomes effective.\\n     */\\n    function withUpdate(\\n        Delay self,\\n        uint32 newValue,\\n        uint32 minSetback\\n    ) internal view returns (Delay updatedDelay, uint48 effect) {\\n        uint32 value = self.get();\\n        uint32 setback = uint32(Math.max(minSetback, value > newValue ? value - newValue : 0));\\n        effect = timestamp() + setback;\\n        return (pack(value, newValue, effect), effect);\\n    }\\n\\n    /**\\n     * @dev Split a delay into its components: valueBefore, valueAfter and effect (transition timepoint).\\n     */\\n    function unpack(Delay self) internal pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        uint112 raw = Delay.unwrap(self);\\n\\n        valueAfter = uint32(raw);\\n        valueBefore = uint32(raw >> 32);\\n        effect = uint48(raw >> 64);\\n\\n        return (valueBefore, valueAfter, effect);\\n    }\\n\\n    /**\\n     * @dev pack the components into a Delay object.\\n     */\\n    function pack(uint32 valueBefore, uint32 valueAfter, uint48 effect) internal pure returns (Delay) {\\n        return Delay.wrap((uint112(effect) << 64) | (uint112(valueBefore) << 32) | uint112(valueAfter));\\n    }\\n}\\n\",\"keccak256\":\"0x36776530f012618bc7526ceb28e77b85e582cb12d9b9466a71d4bd6bf952e4cc\",\"license\":\"MIT\"},\"contracts/helpers/BaseHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IHarvester.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer\\n  uint96 maxSlippage;\\n}\\n\\n/// @title BaseHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a harvester that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseHarvester is IHarvester, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Max slippage when dealing with the Parallelizer\\n  mapping(address => uint96) public maxTokenSlippage;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage > 1e9) revert InvalidParam();\\n    maxTokenSlippage[yieldBearingAsset] = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x82e2ae57997043160d7529488b34591c710cd74e267213b61009daa96e9eeaaf\",\"license\":\"GPL-3.0\"},\"contracts/helpers/GenericHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseHarvester, YieldBearingParams } from \\\"./BaseHarvester.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for anyone to permissionlessly adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseHarvester(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this) || fee != 0) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n\\n    // Swap to tokenIn\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x604c4f9c755b2eb704dc15ba59046201c0258134ef2fbe15a529c510c68cb40a\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaa9eba6ee7770d6146fedbfef07ad10ff09524692319ca0cc32abfa64a2b597b\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IHarvester {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0d4e8fee737f4f747060a3c5044c8cb2f153faa228ad37a661a659ca62aab055\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IParallelizer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IParallelizer.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper\\n{ }\\n\",\"keccak256\":\"0x8bd964110c6a122bdb6cf58a194a97c894900237ebd7f3b11e2f43c6ee56ae7c\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0xb3522ee0380b321c64d02bf2db2acb658d8b314b811dd54b6a718d6708b5fb21\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Changes the pause status for mint or burn transactions for `collateral`\\n  function togglePause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xc3fb2012e7c2f97ae93b12276afc4293aaeb97a6fe4d60109acaa94ef6945575\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0x47e4b2742a51b82b9df72fb681335affe8519f4114fb540cd29d8f48ed182ffd\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType;\\n}\\n// Whether an address is whitelisted for a specific whitelist type\\n\",\"keccak256\":\"0x3f4313dd110dbe390038320b2d3cf24dcbe9b75cd9573e7f048f7233c02dd227\",\"license\":\"BUSL-1.1\"},\"contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror Paused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\n\",\"keccak256\":\"0x1e2f6812ef78e948e5155d32213b52afff8c0ba5463d18bee10694efbf886130\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
-  "bytecode": "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",
-  "deployedBytecode": "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",
-  "devdoc": {
-    "author": "Cooper Labs",
-    "custom:contact": "security@cooperlabs.xyz",
-    "details": "Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
-    "errors": {
-      "SafeERC20FailedOperation(address)": [
-        {
-          "details": "An operation with an ERC-20 token failed."
-        }
-      ]
-    },
-    "events": {
-      "AuthorityUpdated(address)": {
-        "details": "Authority that manages this contract was updated."
-      }
-    },
-    "kind": "dev",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to add to the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "authority()": {
-        "details": "Returns the current authority."
-      },
-      "computeRebalanceAmount(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        },
-        "returns": {
-          "amount": "amount to be rebalanced",
-          "increase": "whether the exposure should be increased"
-        }
-      },
-      "harvest(address,uint256,bytes)": {
-        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage"
-      },
-      "isConsumingScheduledOp()": {
-        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
-      },
-      "onFlashLoan(address,address,uint256,uint256,bytes)": {
-        "details": "Receive a flash loan.",
-        "params": {
-          "amount": "The amount of tokens lent.",
-          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
-          "fee": "The additional amount of tokens to repay.",
-          "initiator": "The initiator of the loan.",
-          "token": "The loan currency."
-        },
-        "returns": {
-          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
-        }
-      },
-      "recoverERC20(address,uint256,address)": {
-        "params": {
-          "amountToRecover": "amount to recover",
-          "to": "address to send the recovered tokens",
-          "tokenAddress": "address of the token to recover"
-        }
-      },
-      "removeBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to remove from the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "setAuthority(address)": {
-        "details": "Transfers control to a new authority. The caller must be the current authority."
-      },
-      "setMaxSlippage(address,uint96)": {
-        "params": {
-          "newMaxSlippage": "new max allowed slippage"
-        }
-      },
-      "setSwapRouter(address)": {
-        "params": {
-          "newSwapRouter": "address of the swap router"
-        }
-      },
-      "setTargetExposure(address,uint64)": {
-        "params": {
-          "targetExposure": "target exposure to the yield bearing asset used",
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      },
-      "setTokenTransferAddress(address)": {
-        "params": {
-          "newTokenTransferAddress": "address of the token transfer contract"
-        }
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "params": {
-          "asset": "address of the asset",
-          "maxExposure": "maximum exposure within the Parallelizer to the asset",
-          "minExposure": "minimum exposure within the Parallelizer to the asset",
-          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
-          "targetExposure": "target exposure to the yieldBearingAsset asset used",
-          "yieldBearingAsset": "address of the yieldBearingAsset"
-        }
-      },
-      "toggleTrusted(address)": {
-        "params": {
-          "trusted": "address to toggle the trusted status"
-        }
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      }
-    },
-    "title": "GenericHarvester",
-    "version": 1
-  },
-  "userdoc": {
-    "events": {
-      "SwapRouterUpdated(address)": {
-        "notice": "Event emitted when the swap router is updated"
-      },
-      "TokenTransferAddressUpdated(address)": {
-        "notice": "Event emitted when the token proxy is updated"
-      }
-    },
-    "kind": "user",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "notice": "Add budget to be spent by the receiver during the flashloan"
-      },
-      "budget(address)": {
-        "notice": "Budget of tokenP available for each users"
-      },
-      "computeRebalanceAmount(address)": {
-        "notice": "Compute the amount needed to rebalance the Parallelizer"
-      },
-      "flashloan()": {
-        "notice": "Parallel stablecoin flashloan contract"
-      },
-      "harvest(address,uint256,bytes)": {
-        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
-      },
-      "isTrusted(address)": {
-        "notice": "trusted addresses that can update target exposure and do others non critical operations"
-      },
-      "maxTokenSlippage(address)": {
-        "notice": "Max slippage when dealing with the Parallelizer"
-      },
-      "parallelizer()": {
-        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
-      },
-      "recoverERC20(address,uint256,address)": {
-        "notice": "Recover ERC20 tokens"
-      },
-      "removeBudget(uint256,address)": {
-        "notice": "Remove budget from the owner and send it to the receiver"
-      },
-      "setMaxSlippage(address,uint96)": {
-        "notice": "Set the max allowed slippage"
-      },
-      "setSwapRouter(address)": {
-        "notice": "Set the swap router"
-      },
-      "setTargetExposure(address,uint64)": {
-        "notice": "Set the target exposure of a yield bearing asset"
-      },
-      "setTokenTransferAddress(address)": {
-        "notice": "Set the token transfer address"
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "notice": "Set the yieldBearingAsset data"
-      },
-      "swapRouter()": {
-        "notice": "address of the router/aggregator"
-      },
-      "toggleTrusted(address)": {
-        "notice": "Toggle the trusted status of an address"
-      },
-      "tokenP()": {
-        "notice": "TokenP handled by the `parallelizer` of interest"
-      },
-      "tokenTransferAddress()": {
-        "notice": "address to approve to transfer tokens to"
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
-      },
-      "yieldBearingData(address)": {
-        "notice": "Data associated to a yield bearing asset"
-      }
-    },
-    "version": 1
-  },
-  "storageLayout": {
-    "storage": [
-      {
-        "astId": 22996,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_authority",
-        "offset": 0,
-        "slot": "0",
-        "type": "t_address"
-      },
-      {
-        "astId": 22998,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_consumingSchedule",
-        "offset": 20,
-        "slot": "0",
-        "type": "t_bool"
-      },
-      {
-        "astId": 8228,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "maxTokenSlippage",
-        "offset": 0,
-        "slot": "1",
-        "type": "t_mapping(t_address,t_uint96)"
-      },
-      {
-        "astId": 8234,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "yieldBearingData",
-        "offset": 0,
-        "slot": "2",
-        "type": "t_mapping(t_address,t_struct(YieldBearingParams)8169_storage)"
-      },
-      {
-        "astId": 8239,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "isTrusted",
-        "offset": 0,
-        "slot": "3",
-        "type": "t_mapping(t_address,t_bool)"
-      },
-      {
-        "astId": 43,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "swapRouter",
-        "offset": 0,
-        "slot": "4",
-        "type": "t_address"
-      },
-      {
-        "astId": 46,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "tokenTransferAddress",
-        "offset": 0,
-        "slot": "5",
-        "type": "t_address"
-      },
-      {
-        "astId": 8955,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "budget",
-        "offset": 0,
-        "slot": "6",
-        "type": "t_mapping(t_address,t_uint256)"
-      }
-    ],
-    "types": {
-      "t_address": {
-        "encoding": "inplace",
-        "label": "address",
-        "numberOfBytes": "20"
-      },
-      "t_bool": {
-        "encoding": "inplace",
-        "label": "bool",
-        "numberOfBytes": "1"
-      },
-      "t_mapping(t_address,t_bool)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => bool)",
-        "numberOfBytes": "32",
-        "value": "t_bool"
-      },
-      "t_mapping(t_address,t_struct(YieldBearingParams)8169_storage)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => struct YieldBearingParams)",
-        "numberOfBytes": "32",
-        "value": "t_struct(YieldBearingParams)8169_storage"
-      },
-      "t_mapping(t_address,t_uint256)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint256)",
-        "numberOfBytes": "32",
-        "value": "t_uint256"
-      },
-      "t_mapping(t_address,t_uint96)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint96)",
-        "numberOfBytes": "32",
-        "value": "t_uint96"
-      },
-      "t_struct(YieldBearingParams)8169_storage": {
-        "encoding": "inplace",
-        "label": "struct YieldBearingParams",
-        "members": [
-          {
-            "astId": 8158,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "asset",
-            "offset": 0,
-            "slot": "0",
-            "type": "t_address"
-          },
-          {
-            "astId": 8160,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "targetExposure",
-            "offset": 20,
-            "slot": "0",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8162,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxExposure",
-            "offset": 0,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8164,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "minExposure",
-            "offset": 8,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8166,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "overrideExposures",
-            "offset": 16,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8168,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxSlippage",
-            "offset": 0,
-            "slot": "2",
-            "type": "t_uint96"
-          }
-        ],
-        "numberOfBytes": "96"
-      },
-      "t_uint256": {
-        "encoding": "inplace",
-        "label": "uint256",
-        "numberOfBytes": "32"
-      },
-      "t_uint64": {
-        "encoding": "inplace",
-        "label": "uint64",
-        "numberOfBytes": "8"
-      },
-      "t_uint96": {
-        "encoding": "inplace",
-        "label": "uint96",
-        "numberOfBytes": "12"
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/deployments/hyperevm/GenericHarvester_USDp.json b/deployments/hyperevm/GenericHarvester_USDp.json
deleted file mode 100644
index e1ef8fc..0000000
--- a/deployments/hyperevm/GenericHarvester_USDp.json
+++ /dev/null
@@ -1,1124 +0,0 @@
-{
-  "address": "0x57770C1721Eb35509f38210A935c8b1911db7E0e",
-  "abi": [
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initialTokenTransferAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialSwapRouter",
-          "type": "address"
-        },
-        {
-          "internalType": "contract ITokenP",
-          "name": "definitivetokenP",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IParallelizer",
-          "name": "definitiveParallelizer",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialAuthority",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "definitiveFlashloan",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedInvalidAuthority",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        },
-        {
-          "internalType": "uint32",
-          "name": "delay",
-          "type": "uint32"
-        }
-      ],
-      "name": "AccessManagedRequiredDelay",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedUnauthorized",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "InvalidParam",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrusted",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrustedOrGuardian",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        }
-      ],
-      "name": "SafeERC20FailedOperation",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "SwapError",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAddress",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAmount",
-      "type": "error"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AuthorityUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "Recovered",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "SwapRouterUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "TokenTransferAddressUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "bool",
-          "name": "status",
-          "type": "bool"
-        }
-      ],
-      "name": "TrustedToggled",
-      "type": "event"
-    },
-    {
-      "inputs": [],
-      "name": "CALLBACK_SUCCESS",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "addBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "authority",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "budget",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "computeRebalanceAmount",
-      "outputs": [
-        {
-          "internalType": "uint8",
-          "name": "increase",
-          "type": "uint8"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "flashloan",
-      "outputs": [
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "scale",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "extraData",
-          "type": "bytes"
-        }
-      ],
-      "name": "harvest",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "isConsumingScheduledOp",
-      "outputs": [
-        {
-          "internalType": "bytes4",
-          "name": "",
-          "type": "bytes4"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "isTrusted",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "maxTokenSlippage",
-      "outputs": [
-        {
-          "internalType": "uint96",
-          "name": "",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initiator",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "fee",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "name": "onFlashLoan",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "parallelizer",
-      "outputs": [
-        {
-          "internalType": "contract IParallelizer",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "tokenAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountToRecover",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "recoverERC20",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "removeBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newAuthority",
-          "type": "address"
-        }
-      ],
-      "name": "setAuthority",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint96",
-          "name": "newMaxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setMaxSlippage",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "setSwapRouter",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        }
-      ],
-      "name": "setTargetExposure",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "setTokenTransferAddress",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setYieldBearingAssetData",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "swapRouter",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        }
-      ],
-      "name": "toggleTrusted",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenP",
-      "outputs": [
-        {
-          "internalType": "contract ITokenP",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenTransferAddress",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "updateLimitExposuresYieldAsset",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "yieldBearingData",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "transactionHash": "0x6c350767c797c798d57bc744249b0a5a16583184117d70fbfd341c0218768067",
-  "receipt": {
-    "to": null,
-    "from": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02",
-    "contractAddress": "0x57770C1721Eb35509f38210A935c8b1911db7E0e",
-    "transactionIndex": 0,
-    "gasUsed": "2210613",
-    "logsBloom": "0x08000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000200000000000000000000000000000000000000000100100000000000800000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000040000000000000009000000000002000000000000000000020000000000000000000000080000000000000000000000000000000000000000000000000000000000100000000000200000000000000000000000000000000210000000000000000008000000000000000000000000000000000000000000",
-    "blockHash": "0xe3c06780634d363711f4758fa230c97447200aeeefe7732b7a7cc015cfc5428a",
-    "transactionHash": "0x6c350767c797c798d57bc744249b0a5a16583184117d70fbfd341c0218768067",
-    "logs": [
-      {
-        "transactionIndex": 0,
-        "blockNumber": 6538100,
-        "transactionHash": "0x6c350767c797c798d57bc744249b0a5a16583184117d70fbfd341c0218768067",
-        "address": "0x57770C1721Eb35509f38210A935c8b1911db7E0e",
-        "topics": [
-          "0x2f658b440c35314f52658ea8a740e05b284cdc84dc9ae01e891f21b8933e7cad"
-        ],
-        "data": "0x000000000000000000000000fd28f108e95f4d41daae9dbfff707d677985998e",
-        "logIndex": 0,
-        "blockHash": "0xe3c06780634d363711f4758fa230c97447200aeeefe7732b7a7cc015cfc5428a"
-      },
-      {
-        "transactionIndex": 0,
-        "blockNumber": 6538100,
-        "transactionHash": "0x6c350767c797c798d57bc744249b0a5a16583184117d70fbfd341c0218768067",
-        "address": "0xBE65F0F410A72BeC163dC65d46c83699e957D588",
-        "topics": [
-          "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
-          "0x00000000000000000000000057770c1721eb35509f38210a935c8b1911db7e0e",
-          "0x00000000000000000000000015452454a9735d68df430879b2941316a09295b1"
-        ],
-        "data": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-        "logIndex": 1,
-        "blockHash": "0xe3c06780634d363711f4758fa230c97447200aeeefe7732b7a7cc015cfc5428a"
-      }
-    ],
-    "blockNumber": 6538100,
-    "cumulativeGasUsed": "2210613",
-    "status": 1,
-    "byzantium": true
-  },
-  "args": [
-    "0x744489ee3d540777a66f2cf297479745e0852f7a",
-    "0x744489ee3d540777a66f2cf297479745e0852f7a",
-    "0xBE65F0F410A72BeC163dC65d46c83699e957D588",
-    "0x1250304F66404cd153fA39388DDCDAec7E0f1707",
-    "0xfD28f108e95f4D41daAE9dbfFf707D677985998E",
-    "0x15452454A9735D68df430879B2941316a09295B1"
-  ],
-  "numDeployments": 1,
-  "solcInputHash": "ac7717979711c6e452015444ccc68db6",
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"maxTokenSlippage\",\"outputs\":[{\"internalType\":\"uint96\",\"name\":\"\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint96\",\"name\":\"newMaxSlippage\",\"type\":\"uint96\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"Receive a flash loan.\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint96)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericHarvester\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"maxTokenSlippage(address)\":{\"notice\":\"Max slippage when dealing with the Parallelizer\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"setMaxSlippage(address,uint96)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/helpers/GenericHarvester.sol\":\"GenericHarvester\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"},\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        (bool success, bytes memory data) = authority.staticcall(\\n            abi.encodeCall(IAuthority.canCall, (caller, target, selector))\\n        );\\n        if (success) {\\n            if (data.length >= 0x40) {\\n                (immediate, delay) = abi.decode(data, (bool, uint32));\\n            } else if (data.length >= 0x20) {\\n                immediate = abi.decode(data, (bool));\\n            }\\n        }\\n        return (immediate, delay);\\n    }\\n}\\n\",\"keccak256\":\"0xb3875997b0d8705e29aa20fee88e1dfef93df438794ae1ad8ba2eb016a4dd4e4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity ^0.8.20;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaba93d42cd70e1418782951132d97b31ddce5f50ad81090884b6d0e41caac9d6\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Time} from \\\"../../utils/types/Time.sol\\\";\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `immediate` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x9be2d08a326515805bc9cf6315b7953f8d1ebe88abf48c2d645fb1fa8211a0e2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAuthority.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x4cc0766bd7fb7b3bafb70afa2a93b6e313a0baec7a35ad1b57505be7861c1030\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x0b1459615b9b47c2a4eec8e72f23ccc601f1d711f679a1c06b3390459021a341\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x5d19ea24c555cf6a5dbafea9fac57887cc3e72154f3ee8e0a2bf67971811c14b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x4ea01544758fd2c7045961904686bfe232d2220a04ecaa2d6b08dac17827febf\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            if (c < a) return (false, 0);\\n            return (true, c);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b > a) return (false, 0);\\n            return (true, a - b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n            // benefit is lost if 'b' is also tested.\\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n            if (a == 0) return (true, 0);\\n            uint256 c = a * b;\\n            if (c / a != b) return (false, 0);\\n            return (true, c);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b == 0) return (false, 0);\\n            return (true, a / b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b == 0) return (false, 0);\\n            return (true, a % b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n            // variables such that product = prod1 * 2\\u00b2\\u2075\\u2076 + prod0.\\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\\n            uint256 prod1; // Most significant 256 bits of the product\\n            assembly {\\n                let mm := mulmod(x, y, not(0))\\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n            }\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (prod1 == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return prod0 / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= prod1) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [prod1 prod0].\\n            uint256 remainder;\\n            assembly {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                prod1 := sub(prod1, gt(remainder, prod0))\\n                prod0 := sub(prod0, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [prod1 prod0] by twos.\\n                prod0 := div(prod0, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from prod1 into prod0.\\n            prod0 |= prod1 * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and prod1\\n            // is no longer required.\\n            result = prod0 * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        uint256 exp;\\n        unchecked {\\n            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            result += SafeCast.toUint(value > 1);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        uint256 isGt;\\n        unchecked {\\n            isGt = SafeCast.toUint(value > (1 << 128) - 1);\\n            value >>= isGt * 128;\\n            result += isGt * 16;\\n\\n            isGt = SafeCast.toUint(value > (1 << 64) - 1);\\n            value >>= isGt * 64;\\n            result += isGt * 8;\\n\\n            isGt = SafeCast.toUint(value > (1 << 32) - 1);\\n            value >>= isGt * 32;\\n            result += isGt * 4;\\n\\n            isGt = SafeCast.toUint(value > (1 << 16) - 1);\\n            value >>= isGt * 16;\\n            result += isGt * 2;\\n\\n            result += SafeCast.toUint(value > (1 << 8) - 1);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0xa00be322d7db5786750ce0ac7e2f5b633ac30a5ed5fa1ced1e74acfc19acecea\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/types/Time.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/types/Time.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Math} from \\\"../math/Math.sol\\\";\\nimport {SafeCast} from \\\"../math/SafeCast.sol\\\";\\n\\n/**\\n * @dev This library provides helpers for manipulating time-related objects.\\n *\\n * It uses the following types:\\n * - `uint48` for timepoints\\n * - `uint32` for durations\\n *\\n * While the library doesn't provide specific types for timepoints and duration, it does provide:\\n * - a `Delay` type to represent duration that can be programmed to change value automatically at a given point\\n * - additional helper functions\\n */\\nlibrary Time {\\n    using Time for *;\\n\\n    /**\\n     * @dev Get the block timestamp as a Timepoint.\\n     */\\n    function timestamp() internal view returns (uint48) {\\n        return SafeCast.toUint48(block.timestamp);\\n    }\\n\\n    /**\\n     * @dev Get the block number as a Timepoint.\\n     */\\n    function blockNumber() internal view returns (uint48) {\\n        return SafeCast.toUint48(block.number);\\n    }\\n\\n    // ==================================================== Delay =====================================================\\n    /**\\n     * @dev A `Delay` is a uint32 duration that can be programmed to change value automatically at a given point in the\\n     * future. The \\\"effect\\\" timepoint describes when the transitions happens from the \\\"old\\\" value to the \\\"new\\\" value.\\n     * This allows updating the delay applied to some operation while keeping some guarantees.\\n     *\\n     * In particular, the {update} function guarantees that if the delay is reduced, the old delay still applies for\\n     * some time. For example if the delay is currently 7 days to do an upgrade, the admin should not be able to set\\n     * the delay to 0 and upgrade immediately. If the admin wants to reduce the delay, the old delay (7 days) should\\n     * still apply for some time.\\n     *\\n     *\\n     * The `Delay` type is 112 bits long, and packs the following:\\n     *\\n     * ```\\n     *   | [uint48]: effect date (timepoint)\\n     *   |           | [uint32]: value before (duration)\\n     *   \\u2193           \\u2193       \\u2193 [uint32]: value after (duration)\\n     * 0xAAAAAAAAAAAABBBBBBBBCCCCCCCC\\n     * ```\\n     *\\n     * NOTE: The {get} and {withUpdate} functions operate using timestamps. Block number based delays are not currently\\n     * supported.\\n     */\\n    type Delay is uint112;\\n\\n    /**\\n     * @dev Wrap a duration into a Delay to add the one-step \\\"update in the future\\\" feature\\n     */\\n    function toDelay(uint32 duration) internal pure returns (Delay) {\\n        return Delay.wrap(duration);\\n    }\\n\\n    /**\\n     * @dev Get the value at a given timepoint plus the pending value and effect timepoint if there is a scheduled\\n     * change after this timepoint. If the effect timepoint is 0, then the pending value should not be considered.\\n     */\\n    function _getFullAt(\\n        Delay self,\\n        uint48 timepoint\\n    ) private pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        (valueBefore, valueAfter, effect) = self.unpack();\\n        return effect <= timepoint ? (valueAfter, 0, 0) : (valueBefore, valueAfter, effect);\\n    }\\n\\n    /**\\n     * @dev Get the current value plus the pending value and effect timepoint if there is a scheduled change. If the\\n     * effect timepoint is 0, then the pending value should not be considered.\\n     */\\n    function getFull(Delay self) internal view returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        return _getFullAt(self, timestamp());\\n    }\\n\\n    /**\\n     * @dev Get the current value.\\n     */\\n    function get(Delay self) internal view returns (uint32) {\\n        (uint32 delay, , ) = self.getFull();\\n        return delay;\\n    }\\n\\n    /**\\n     * @dev Update a Delay object so that it takes a new duration after a timepoint that is automatically computed to\\n     * enforce the old delay at the moment of the update. Returns the updated Delay object and the timestamp when the\\n     * new delay becomes effective.\\n     */\\n    function withUpdate(\\n        Delay self,\\n        uint32 newValue,\\n        uint32 minSetback\\n    ) internal view returns (Delay updatedDelay, uint48 effect) {\\n        uint32 value = self.get();\\n        uint32 setback = uint32(Math.max(minSetback, value > newValue ? value - newValue : 0));\\n        effect = timestamp() + setback;\\n        return (pack(value, newValue, effect), effect);\\n    }\\n\\n    /**\\n     * @dev Split a delay into its components: valueBefore, valueAfter and effect (transition timepoint).\\n     */\\n    function unpack(Delay self) internal pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        uint112 raw = Delay.unwrap(self);\\n\\n        valueAfter = uint32(raw);\\n        valueBefore = uint32(raw >> 32);\\n        effect = uint48(raw >> 64);\\n\\n        return (valueBefore, valueAfter, effect);\\n    }\\n\\n    /**\\n     * @dev pack the components into a Delay object.\\n     */\\n    function pack(uint32 valueBefore, uint32 valueAfter, uint48 effect) internal pure returns (Delay) {\\n        return Delay.wrap((uint112(effect) << 64) | (uint112(valueBefore) << 32) | uint112(valueAfter));\\n    }\\n}\\n\",\"keccak256\":\"0x36776530f012618bc7526ceb28e77b85e582cb12d9b9466a71d4bd6bf952e4cc\",\"license\":\"MIT\"},\"contracts/helpers/BaseHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IHarvester.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer\\n  uint96 maxSlippage;\\n}\\n\\n/// @title BaseHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a harvester that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseHarvester is IHarvester, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Max slippage when dealing with the Parallelizer\\n  mapping(address => uint96) public maxTokenSlippage;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage > 1e9) revert InvalidParam();\\n    maxTokenSlippage[yieldBearingAsset] = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x82e2ae57997043160d7529488b34591c710cd74e267213b61009daa96e9eeaaf\",\"license\":\"GPL-3.0\"},\"contracts/helpers/GenericHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Constants.sol\\\";\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseHarvester, YieldBearingParams } from \\\"./BaseHarvester.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for anyone to permissionlessly adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseHarvester(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this) || fee != 0) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n\\n    // Swap to tokenIn\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x764fdb8964ca0b949d1b3f336cd8046c9c77c86aae4011b0a8760cedc5bb7971\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaa9eba6ee7770d6146fedbfef07ad10ff09524692319ca0cc32abfa64a2b597b\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IHarvester {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0d4e8fee737f4f747060a3c5044c8cb2f153faa228ad37a661a659ca62aab055\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IParallelizer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IParallelizer.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper\\n{ }\\n\",\"keccak256\":\"0x8bd964110c6a122bdb6cf58a194a97c894900237ebd7f3b11e2f43c6ee56ae7c\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0xb3522ee0380b321c64d02bf2db2acb658d8b314b811dd54b6a718d6708b5fb21\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Changes the pause status for mint or burn transactions for `collateral`\\n  function togglePause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xc3fb2012e7c2f97ae93b12276afc4293aaeb97a6fe4d60109acaa94ef6945575\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0x47e4b2742a51b82b9df72fb681335affe8519f4114fb540cd29d8f48ed182ffd\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType;\\n}\\n// Whether an address is whitelisted for a specific whitelist type\\n\",\"keccak256\":\"0x3f4313dd110dbe390038320b2d3cf24dcbe9b75cd9573e7f048f7233c02dd227\",\"license\":\"BUSL-1.1\"},\"contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0x19cEeAd7105607Cd444F5ad10dd51356436095a1;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0xc96a9c89a4d1b9f1a7f4ff42f56942d6f757e5b8528ecea53b18b68e2f88b559\",\"license\":\"BUSL-1.1\"},\"contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror Paused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\n\",\"keccak256\":\"0x1e2f6812ef78e948e5155d32213b52afff8c0ba5463d18bee10694efbf886130\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
-  "bytecode": "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",
-  "deployedBytecode": "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",
-  "devdoc": {
-    "author": "Cooper Labs",
-    "custom:contact": "security@cooperlabs.xyz",
-    "details": "Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
-    "errors": {
-      "SafeERC20FailedOperation(address)": [
-        {
-          "details": "An operation with an ERC-20 token failed."
-        }
-      ]
-    },
-    "events": {
-      "AuthorityUpdated(address)": {
-        "details": "Authority that manages this contract was updated."
-      }
-    },
-    "kind": "dev",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to add to the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "authority()": {
-        "details": "Returns the current authority."
-      },
-      "computeRebalanceAmount(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        },
-        "returns": {
-          "amount": "amount to be rebalanced",
-          "increase": "whether the exposure should be increased"
-        }
-      },
-      "harvest(address,uint256,bytes)": {
-        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage"
-      },
-      "isConsumingScheduledOp()": {
-        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
-      },
-      "onFlashLoan(address,address,uint256,uint256,bytes)": {
-        "details": "Receive a flash loan.",
-        "params": {
-          "amount": "The amount of tokens lent.",
-          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
-          "fee": "The additional amount of tokens to repay.",
-          "initiator": "The initiator of the loan.",
-          "token": "The loan currency."
-        },
-        "returns": {
-          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
-        }
-      },
-      "recoverERC20(address,uint256,address)": {
-        "params": {
-          "amountToRecover": "amount to recover",
-          "to": "address to send the recovered tokens",
-          "tokenAddress": "address of the token to recover"
-        }
-      },
-      "removeBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to remove from the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "setAuthority(address)": {
-        "details": "Transfers control to a new authority. The caller must be the current authority."
-      },
-      "setMaxSlippage(address,uint96)": {
-        "params": {
-          "newMaxSlippage": "new max allowed slippage"
-        }
-      },
-      "setSwapRouter(address)": {
-        "params": {
-          "newSwapRouter": "address of the swap router"
-        }
-      },
-      "setTargetExposure(address,uint64)": {
-        "params": {
-          "targetExposure": "target exposure to the yield bearing asset used",
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      },
-      "setTokenTransferAddress(address)": {
-        "params": {
-          "newTokenTransferAddress": "address of the token transfer contract"
-        }
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "params": {
-          "asset": "address of the asset",
-          "maxExposure": "maximum exposure within the Parallelizer to the asset",
-          "minExposure": "minimum exposure within the Parallelizer to the asset",
-          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
-          "targetExposure": "target exposure to the yieldBearingAsset asset used",
-          "yieldBearingAsset": "address of the yieldBearingAsset"
-        }
-      },
-      "toggleTrusted(address)": {
-        "params": {
-          "trusted": "address to toggle the trusted status"
-        }
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      }
-    },
-    "title": "GenericHarvester",
-    "version": 1
-  },
-  "userdoc": {
-    "events": {
-      "SwapRouterUpdated(address)": {
-        "notice": "Event emitted when the swap router is updated"
-      },
-      "TokenTransferAddressUpdated(address)": {
-        "notice": "Event emitted when the token proxy is updated"
-      }
-    },
-    "kind": "user",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "notice": "Add budget to be spent by the receiver during the flashloan"
-      },
-      "budget(address)": {
-        "notice": "Budget of tokenP available for each users"
-      },
-      "computeRebalanceAmount(address)": {
-        "notice": "Compute the amount needed to rebalance the Parallelizer"
-      },
-      "flashloan()": {
-        "notice": "Parallel stablecoin flashloan contract"
-      },
-      "harvest(address,uint256,bytes)": {
-        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
-      },
-      "isTrusted(address)": {
-        "notice": "trusted addresses that can update target exposure and do others non critical operations"
-      },
-      "maxTokenSlippage(address)": {
-        "notice": "Max slippage when dealing with the Parallelizer"
-      },
-      "parallelizer()": {
-        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
-      },
-      "recoverERC20(address,uint256,address)": {
-        "notice": "Recover ERC20 tokens"
-      },
-      "removeBudget(uint256,address)": {
-        "notice": "Remove budget from the owner and send it to the receiver"
-      },
-      "setMaxSlippage(address,uint96)": {
-        "notice": "Set the max allowed slippage"
-      },
-      "setSwapRouter(address)": {
-        "notice": "Set the swap router"
-      },
-      "setTargetExposure(address,uint64)": {
-        "notice": "Set the target exposure of a yield bearing asset"
-      },
-      "setTokenTransferAddress(address)": {
-        "notice": "Set the token transfer address"
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "notice": "Set the yieldBearingAsset data"
-      },
-      "swapRouter()": {
-        "notice": "address of the router/aggregator"
-      },
-      "toggleTrusted(address)": {
-        "notice": "Toggle the trusted status of an address"
-      },
-      "tokenP()": {
-        "notice": "TokenP handled by the `parallelizer` of interest"
-      },
-      "tokenTransferAddress()": {
-        "notice": "address to approve to transfer tokens to"
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
-      },
-      "yieldBearingData(address)": {
-        "notice": "Data associated to a yield bearing asset"
-      }
-    },
-    "version": 1
-  },
-  "storageLayout": {
-    "storage": [
-      {
-        "astId": 22997,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_authority",
-        "offset": 0,
-        "slot": "0",
-        "type": "t_address"
-      },
-      {
-        "astId": 22999,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_consumingSchedule",
-        "offset": 20,
-        "slot": "0",
-        "type": "t_bool"
-      },
-      {
-        "astId": 8228,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "maxTokenSlippage",
-        "offset": 0,
-        "slot": "1",
-        "type": "t_mapping(t_address,t_uint96)"
-      },
-      {
-        "astId": 8234,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "yieldBearingData",
-        "offset": 0,
-        "slot": "2",
-        "type": "t_mapping(t_address,t_struct(YieldBearingParams)8169_storage)"
-      },
-      {
-        "astId": 8239,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "isTrusted",
-        "offset": 0,
-        "slot": "3",
-        "type": "t_mapping(t_address,t_bool)"
-      },
-      {
-        "astId": 43,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "swapRouter",
-        "offset": 0,
-        "slot": "4",
-        "type": "t_address"
-      },
-      {
-        "astId": 46,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "tokenTransferAddress",
-        "offset": 0,
-        "slot": "5",
-        "type": "t_address"
-      },
-      {
-        "astId": 8956,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "budget",
-        "offset": 0,
-        "slot": "6",
-        "type": "t_mapping(t_address,t_uint256)"
-      }
-    ],
-    "types": {
-      "t_address": {
-        "encoding": "inplace",
-        "label": "address",
-        "numberOfBytes": "20"
-      },
-      "t_bool": {
-        "encoding": "inplace",
-        "label": "bool",
-        "numberOfBytes": "1"
-      },
-      "t_mapping(t_address,t_bool)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => bool)",
-        "numberOfBytes": "32",
-        "value": "t_bool"
-      },
-      "t_mapping(t_address,t_struct(YieldBearingParams)8169_storage)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => struct YieldBearingParams)",
-        "numberOfBytes": "32",
-        "value": "t_struct(YieldBearingParams)8169_storage"
-      },
-      "t_mapping(t_address,t_uint256)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint256)",
-        "numberOfBytes": "32",
-        "value": "t_uint256"
-      },
-      "t_mapping(t_address,t_uint96)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint96)",
-        "numberOfBytes": "32",
-        "value": "t_uint96"
-      },
-      "t_struct(YieldBearingParams)8169_storage": {
-        "encoding": "inplace",
-        "label": "struct YieldBearingParams",
-        "members": [
-          {
-            "astId": 8158,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "asset",
-            "offset": 0,
-            "slot": "0",
-            "type": "t_address"
-          },
-          {
-            "astId": 8160,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "targetExposure",
-            "offset": 20,
-            "slot": "0",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8162,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxExposure",
-            "offset": 0,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8164,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "minExposure",
-            "offset": 8,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8166,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "overrideExposures",
-            "offset": 16,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8168,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxSlippage",
-            "offset": 0,
-            "slot": "2",
-            "type": "t_uint96"
-          }
-        ],
-        "numberOfBytes": "96"
-      },
-      "t_uint256": {
-        "encoding": "inplace",
-        "label": "uint256",
-        "numberOfBytes": "32"
-      },
-      "t_uint64": {
-        "encoding": "inplace",
-        "label": "uint64",
-        "numberOfBytes": "8"
-      },
-      "t_uint96": {
-        "encoding": "inplace",
-        "label": "uint96",
-        "numberOfBytes": "12"
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/deployments/mainnet/GenericHarvester_USDp.json b/deployments/mainnet/GenericHarvester_USDp.json
deleted file mode 100644
index ed0ab7c..0000000
--- a/deployments/mainnet/GenericHarvester_USDp.json
+++ /dev/null
@@ -1,1124 +0,0 @@
-{
-  "address": "0x36DA06796fD9d22BCD6287b66A87FfdadB12636C",
-  "abi": [
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initialTokenTransferAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialSwapRouter",
-          "type": "address"
-        },
-        {
-          "internalType": "contract ITokenP",
-          "name": "definitivetokenP",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IParallelizer",
-          "name": "definitiveParallelizer",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialAuthority",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "definitiveFlashloan",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedInvalidAuthority",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        },
-        {
-          "internalType": "uint32",
-          "name": "delay",
-          "type": "uint32"
-        }
-      ],
-      "name": "AccessManagedRequiredDelay",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedUnauthorized",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "InvalidParam",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrusted",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrustedOrGuardian",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        }
-      ],
-      "name": "SafeERC20FailedOperation",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "SwapError",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAddress",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAmount",
-      "type": "error"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AuthorityUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "Recovered",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "SwapRouterUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "TokenTransferAddressUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "bool",
-          "name": "status",
-          "type": "bool"
-        }
-      ],
-      "name": "TrustedToggled",
-      "type": "event"
-    },
-    {
-      "inputs": [],
-      "name": "CALLBACK_SUCCESS",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "addBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "authority",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "budget",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "computeRebalanceAmount",
-      "outputs": [
-        {
-          "internalType": "uint8",
-          "name": "increase",
-          "type": "uint8"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "flashloan",
-      "outputs": [
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "scale",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "extraData",
-          "type": "bytes"
-        }
-      ],
-      "name": "harvest",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "isConsumingScheduledOp",
-      "outputs": [
-        {
-          "internalType": "bytes4",
-          "name": "",
-          "type": "bytes4"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "isTrusted",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "maxTokenSlippage",
-      "outputs": [
-        {
-          "internalType": "uint96",
-          "name": "",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initiator",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "fee",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "name": "onFlashLoan",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "parallelizer",
-      "outputs": [
-        {
-          "internalType": "contract IParallelizer",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "tokenAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountToRecover",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "recoverERC20",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "removeBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newAuthority",
-          "type": "address"
-        }
-      ],
-      "name": "setAuthority",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint96",
-          "name": "newMaxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setMaxSlippage",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "setSwapRouter",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        }
-      ],
-      "name": "setTargetExposure",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "setTokenTransferAddress",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setYieldBearingAssetData",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "swapRouter",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        }
-      ],
-      "name": "toggleTrusted",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenP",
-      "outputs": [
-        {
-          "internalType": "contract ITokenP",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenTransferAddress",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "updateLimitExposuresYieldAsset",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "yieldBearingData",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "transactionHash": "0x78fe720c21dd98061214a9c0d69c36b334885e137b70a84d82896ec5a122ed43",
-  "receipt": {
-    "to": null,
-    "from": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02",
-    "contractAddress": "0x36DA06796fD9d22BCD6287b66A87FfdadB12636C",
-    "transactionIndex": 23,
-    "gasUsed": "2210601",
-    "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000010000000000000000000000000000000000400000000000000000000000000000008000000000000000000040000000000020000000080010000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000008000000000000010011000000000000008000000000000000000000000820000000000000000",
-    "blockHash": "0x72aeb2adc9b23d9bcb197b167959c0e6a72b511afdcb61b2ce66a5d6ef399fa3",
-    "transactionHash": "0x78fe720c21dd98061214a9c0d69c36b334885e137b70a84d82896ec5a122ed43",
-    "logs": [
-      {
-        "transactionIndex": 23,
-        "blockNumber": 22767046,
-        "transactionHash": "0x78fe720c21dd98061214a9c0d69c36b334885e137b70a84d82896ec5a122ed43",
-        "address": "0x36DA06796fD9d22BCD6287b66A87FfdadB12636C",
-        "topics": [
-          "0x2f658b440c35314f52658ea8a740e05b284cdc84dc9ae01e891f21b8933e7cad"
-        ],
-        "data": "0x00000000000000000000000094ea8800444017695345156319e96bdb1e355f7a",
-        "logIndex": 222,
-        "blockHash": "0x72aeb2adc9b23d9bcb197b167959c0e6a72b511afdcb61b2ce66a5d6ef399fa3"
-      },
-      {
-        "transactionIndex": 23,
-        "blockNumber": 22767046,
-        "transactionHash": "0x78fe720c21dd98061214a9c0d69c36b334885e137b70a84d82896ec5a122ed43",
-        "address": "0x9B3a8f7CEC208e247d97dEE13313690977e24459",
-        "topics": [
-          "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
-          "0x00000000000000000000000036da06796fd9d22bcd6287b66a87ffdadb12636c",
-          "0x000000000000000000000000c9b6279baa19dbb8bcc3250c89caa093aaba0bfc"
-        ],
-        "data": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-        "logIndex": 223,
-        "blockHash": "0x72aeb2adc9b23d9bcb197b167959c0e6a72b511afdcb61b2ce66a5d6ef399fa3"
-      }
-    ],
-    "blockNumber": 22767046,
-    "cumulativeGasUsed": "10462236",
-    "status": 1,
-    "byzantium": true
-  },
-  "args": [
-    "0xcf5540fffcdc3d510b18bfca6d2b9987b0772559",
-    "0xcf5540fffcdc3d510b18bfca6d2b9987b0772559",
-    "0x9B3a8f7CEC208e247d97dEE13313690977e24459",
-    "0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2",
-    "0x94Ea8800444017695345156319e96bdB1E355F7a",
-    "0xC9B6279baa19dBB8bCc3250c89cAa093AaBA0bfc"
-  ],
-  "numDeployments": 1,
-  "solcInputHash": "9e6800737641b3b015331b65b5c620c3",
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"maxTokenSlippage\",\"outputs\":[{\"internalType\":\"uint96\",\"name\":\"\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint96\",\"name\":\"newMaxSlippage\",\"type\":\"uint96\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"Receive a flash loan.\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint96)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericHarvester\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"maxTokenSlippage(address)\":{\"notice\":\"Max slippage when dealing with the Parallelizer\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"setMaxSlippage(address,uint96)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/helpers/GenericHarvester.sol\":\"GenericHarvester\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"},\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        (bool success, bytes memory data) = authority.staticcall(\\n            abi.encodeCall(IAuthority.canCall, (caller, target, selector))\\n        );\\n        if (success) {\\n            if (data.length >= 0x40) {\\n                (immediate, delay) = abi.decode(data, (bool, uint32));\\n            } else if (data.length >= 0x20) {\\n                immediate = abi.decode(data, (bool));\\n            }\\n        }\\n        return (immediate, delay);\\n    }\\n}\\n\",\"keccak256\":\"0xb3875997b0d8705e29aa20fee88e1dfef93df438794ae1ad8ba2eb016a4dd4e4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity ^0.8.20;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaba93d42cd70e1418782951132d97b31ddce5f50ad81090884b6d0e41caac9d6\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Time} from \\\"../../utils/types/Time.sol\\\";\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `immediate` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x9be2d08a326515805bc9cf6315b7953f8d1ebe88abf48c2d645fb1fa8211a0e2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAuthority.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x4cc0766bd7fb7b3bafb70afa2a93b6e313a0baec7a35ad1b57505be7861c1030\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x0b1459615b9b47c2a4eec8e72f23ccc601f1d711f679a1c06b3390459021a341\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x5d19ea24c555cf6a5dbafea9fac57887cc3e72154f3ee8e0a2bf67971811c14b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x4ea01544758fd2c7045961904686bfe232d2220a04ecaa2d6b08dac17827febf\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            if (c < a) return (false, 0);\\n            return (true, c);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b > a) return (false, 0);\\n            return (true, a - b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n            // benefit is lost if 'b' is also tested.\\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n            if (a == 0) return (true, 0);\\n            uint256 c = a * b;\\n            if (c / a != b) return (false, 0);\\n            return (true, c);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b == 0) return (false, 0);\\n            return (true, a / b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b == 0) return (false, 0);\\n            return (true, a % b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n            // variables such that product = prod1 * 2\\u00b2\\u2075\\u2076 + prod0.\\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\\n            uint256 prod1; // Most significant 256 bits of the product\\n            assembly {\\n                let mm := mulmod(x, y, not(0))\\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n            }\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (prod1 == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return prod0 / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= prod1) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [prod1 prod0].\\n            uint256 remainder;\\n            assembly {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                prod1 := sub(prod1, gt(remainder, prod0))\\n                prod0 := sub(prod0, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [prod1 prod0] by twos.\\n                prod0 := div(prod0, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from prod1 into prod0.\\n            prod0 |= prod1 * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and prod1\\n            // is no longer required.\\n            result = prod0 * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        uint256 exp;\\n        unchecked {\\n            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            result += SafeCast.toUint(value > 1);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        uint256 isGt;\\n        unchecked {\\n            isGt = SafeCast.toUint(value > (1 << 128) - 1);\\n            value >>= isGt * 128;\\n            result += isGt * 16;\\n\\n            isGt = SafeCast.toUint(value > (1 << 64) - 1);\\n            value >>= isGt * 64;\\n            result += isGt * 8;\\n\\n            isGt = SafeCast.toUint(value > (1 << 32) - 1);\\n            value >>= isGt * 32;\\n            result += isGt * 4;\\n\\n            isGt = SafeCast.toUint(value > (1 << 16) - 1);\\n            value >>= isGt * 16;\\n            result += isGt * 2;\\n\\n            result += SafeCast.toUint(value > (1 << 8) - 1);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0xa00be322d7db5786750ce0ac7e2f5b633ac30a5ed5fa1ced1e74acfc19acecea\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/types/Time.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/types/Time.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Math} from \\\"../math/Math.sol\\\";\\nimport {SafeCast} from \\\"../math/SafeCast.sol\\\";\\n\\n/**\\n * @dev This library provides helpers for manipulating time-related objects.\\n *\\n * It uses the following types:\\n * - `uint48` for timepoints\\n * - `uint32` for durations\\n *\\n * While the library doesn't provide specific types for timepoints and duration, it does provide:\\n * - a `Delay` type to represent duration that can be programmed to change value automatically at a given point\\n * - additional helper functions\\n */\\nlibrary Time {\\n    using Time for *;\\n\\n    /**\\n     * @dev Get the block timestamp as a Timepoint.\\n     */\\n    function timestamp() internal view returns (uint48) {\\n        return SafeCast.toUint48(block.timestamp);\\n    }\\n\\n    /**\\n     * @dev Get the block number as a Timepoint.\\n     */\\n    function blockNumber() internal view returns (uint48) {\\n        return SafeCast.toUint48(block.number);\\n    }\\n\\n    // ==================================================== Delay =====================================================\\n    /**\\n     * @dev A `Delay` is a uint32 duration that can be programmed to change value automatically at a given point in the\\n     * future. The \\\"effect\\\" timepoint describes when the transitions happens from the \\\"old\\\" value to the \\\"new\\\" value.\\n     * This allows updating the delay applied to some operation while keeping some guarantees.\\n     *\\n     * In particular, the {update} function guarantees that if the delay is reduced, the old delay still applies for\\n     * some time. For example if the delay is currently 7 days to do an upgrade, the admin should not be able to set\\n     * the delay to 0 and upgrade immediately. If the admin wants to reduce the delay, the old delay (7 days) should\\n     * still apply for some time.\\n     *\\n     *\\n     * The `Delay` type is 112 bits long, and packs the following:\\n     *\\n     * ```\\n     *   | [uint48]: effect date (timepoint)\\n     *   |           | [uint32]: value before (duration)\\n     *   \\u2193           \\u2193       \\u2193 [uint32]: value after (duration)\\n     * 0xAAAAAAAAAAAABBBBBBBBCCCCCCCC\\n     * ```\\n     *\\n     * NOTE: The {get} and {withUpdate} functions operate using timestamps. Block number based delays are not currently\\n     * supported.\\n     */\\n    type Delay is uint112;\\n\\n    /**\\n     * @dev Wrap a duration into a Delay to add the one-step \\\"update in the future\\\" feature\\n     */\\n    function toDelay(uint32 duration) internal pure returns (Delay) {\\n        return Delay.wrap(duration);\\n    }\\n\\n    /**\\n     * @dev Get the value at a given timepoint plus the pending value and effect timepoint if there is a scheduled\\n     * change after this timepoint. If the effect timepoint is 0, then the pending value should not be considered.\\n     */\\n    function _getFullAt(\\n        Delay self,\\n        uint48 timepoint\\n    ) private pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        (valueBefore, valueAfter, effect) = self.unpack();\\n        return effect <= timepoint ? (valueAfter, 0, 0) : (valueBefore, valueAfter, effect);\\n    }\\n\\n    /**\\n     * @dev Get the current value plus the pending value and effect timepoint if there is a scheduled change. If the\\n     * effect timepoint is 0, then the pending value should not be considered.\\n     */\\n    function getFull(Delay self) internal view returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        return _getFullAt(self, timestamp());\\n    }\\n\\n    /**\\n     * @dev Get the current value.\\n     */\\n    function get(Delay self) internal view returns (uint32) {\\n        (uint32 delay, , ) = self.getFull();\\n        return delay;\\n    }\\n\\n    /**\\n     * @dev Update a Delay object so that it takes a new duration after a timepoint that is automatically computed to\\n     * enforce the old delay at the moment of the update. Returns the updated Delay object and the timestamp when the\\n     * new delay becomes effective.\\n     */\\n    function withUpdate(\\n        Delay self,\\n        uint32 newValue,\\n        uint32 minSetback\\n    ) internal view returns (Delay updatedDelay, uint48 effect) {\\n        uint32 value = self.get();\\n        uint32 setback = uint32(Math.max(minSetback, value > newValue ? value - newValue : 0));\\n        effect = timestamp() + setback;\\n        return (pack(value, newValue, effect), effect);\\n    }\\n\\n    /**\\n     * @dev Split a delay into its components: valueBefore, valueAfter and effect (transition timepoint).\\n     */\\n    function unpack(Delay self) internal pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        uint112 raw = Delay.unwrap(self);\\n\\n        valueAfter = uint32(raw);\\n        valueBefore = uint32(raw >> 32);\\n        effect = uint48(raw >> 64);\\n\\n        return (valueBefore, valueAfter, effect);\\n    }\\n\\n    /**\\n     * @dev pack the components into a Delay object.\\n     */\\n    function pack(uint32 valueBefore, uint32 valueAfter, uint48 effect) internal pure returns (Delay) {\\n        return Delay.wrap((uint112(effect) << 64) | (uint112(valueBefore) << 32) | uint112(valueAfter));\\n    }\\n}\\n\",\"keccak256\":\"0x36776530f012618bc7526ceb28e77b85e582cb12d9b9466a71d4bd6bf952e4cc\",\"license\":\"MIT\"},\"contracts/helpers/BaseHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IHarvester.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer\\n  uint96 maxSlippage;\\n}\\n\\n/// @title BaseHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a harvester that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseHarvester is IHarvester, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Max slippage when dealing with the Parallelizer\\n  mapping(address => uint96) public maxTokenSlippage;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage > 1e9) revert InvalidParam();\\n    maxTokenSlippage[yieldBearingAsset] = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x82e2ae57997043160d7529488b34591c710cd74e267213b61009daa96e9eeaaf\",\"license\":\"GPL-3.0\"},\"contracts/helpers/GenericHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseHarvester, YieldBearingParams } from \\\"./BaseHarvester.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for anyone to permissionlessly adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseHarvester(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this) || fee != 0) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n\\n    // Swap to tokenIn\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x604c4f9c755b2eb704dc15ba59046201c0258134ef2fbe15a529c510c68cb40a\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaa9eba6ee7770d6146fedbfef07ad10ff09524692319ca0cc32abfa64a2b597b\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IHarvester {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0d4e8fee737f4f747060a3c5044c8cb2f153faa228ad37a661a659ca62aab055\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IParallelizer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IParallelizer.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper\\n{ }\\n\",\"keccak256\":\"0x8bd964110c6a122bdb6cf58a194a97c894900237ebd7f3b11e2f43c6ee56ae7c\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0xb3522ee0380b321c64d02bf2db2acb658d8b314b811dd54b6a718d6708b5fb21\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Changes the pause status for mint or burn transactions for `collateral`\\n  function togglePause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xc3fb2012e7c2f97ae93b12276afc4293aaeb97a6fe4d60109acaa94ef6945575\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0x47e4b2742a51b82b9df72fb681335affe8519f4114fb540cd29d8f48ed182ffd\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType;\\n}\\n// Whether an address is whitelisted for a specific whitelist type\\n\",\"keccak256\":\"0x3f4313dd110dbe390038320b2d3cf24dcbe9b75cd9573e7f048f7233c02dd227\",\"license\":\"BUSL-1.1\"},\"contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror Paused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\n\",\"keccak256\":\"0x1e2f6812ef78e948e5155d32213b52afff8c0ba5463d18bee10694efbf886130\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
-  "bytecode": "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",
-  "deployedBytecode": "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",
-  "devdoc": {
-    "author": "Cooper Labs",
-    "custom:contact": "security@cooperlabs.xyz",
-    "details": "Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
-    "errors": {
-      "SafeERC20FailedOperation(address)": [
-        {
-          "details": "An operation with an ERC-20 token failed."
-        }
-      ]
-    },
-    "events": {
-      "AuthorityUpdated(address)": {
-        "details": "Authority that manages this contract was updated."
-      }
-    },
-    "kind": "dev",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to add to the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "authority()": {
-        "details": "Returns the current authority."
-      },
-      "computeRebalanceAmount(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        },
-        "returns": {
-          "amount": "amount to be rebalanced",
-          "increase": "whether the exposure should be increased"
-        }
-      },
-      "harvest(address,uint256,bytes)": {
-        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage"
-      },
-      "isConsumingScheduledOp()": {
-        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
-      },
-      "onFlashLoan(address,address,uint256,uint256,bytes)": {
-        "details": "Receive a flash loan.",
-        "params": {
-          "amount": "The amount of tokens lent.",
-          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
-          "fee": "The additional amount of tokens to repay.",
-          "initiator": "The initiator of the loan.",
-          "token": "The loan currency."
-        },
-        "returns": {
-          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
-        }
-      },
-      "recoverERC20(address,uint256,address)": {
-        "params": {
-          "amountToRecover": "amount to recover",
-          "to": "address to send the recovered tokens",
-          "tokenAddress": "address of the token to recover"
-        }
-      },
-      "removeBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to remove from the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "setAuthority(address)": {
-        "details": "Transfers control to a new authority. The caller must be the current authority."
-      },
-      "setMaxSlippage(address,uint96)": {
-        "params": {
-          "newMaxSlippage": "new max allowed slippage"
-        }
-      },
-      "setSwapRouter(address)": {
-        "params": {
-          "newSwapRouter": "address of the swap router"
-        }
-      },
-      "setTargetExposure(address,uint64)": {
-        "params": {
-          "targetExposure": "target exposure to the yield bearing asset used",
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      },
-      "setTokenTransferAddress(address)": {
-        "params": {
-          "newTokenTransferAddress": "address of the token transfer contract"
-        }
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "params": {
-          "asset": "address of the asset",
-          "maxExposure": "maximum exposure within the Parallelizer to the asset",
-          "minExposure": "minimum exposure within the Parallelizer to the asset",
-          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
-          "targetExposure": "target exposure to the yieldBearingAsset asset used",
-          "yieldBearingAsset": "address of the yieldBearingAsset"
-        }
-      },
-      "toggleTrusted(address)": {
-        "params": {
-          "trusted": "address to toggle the trusted status"
-        }
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      }
-    },
-    "title": "GenericHarvester",
-    "version": 1
-  },
-  "userdoc": {
-    "events": {
-      "SwapRouterUpdated(address)": {
-        "notice": "Event emitted when the swap router is updated"
-      },
-      "TokenTransferAddressUpdated(address)": {
-        "notice": "Event emitted when the token proxy is updated"
-      }
-    },
-    "kind": "user",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "notice": "Add budget to be spent by the receiver during the flashloan"
-      },
-      "budget(address)": {
-        "notice": "Budget of tokenP available for each users"
-      },
-      "computeRebalanceAmount(address)": {
-        "notice": "Compute the amount needed to rebalance the Parallelizer"
-      },
-      "flashloan()": {
-        "notice": "Parallel stablecoin flashloan contract"
-      },
-      "harvest(address,uint256,bytes)": {
-        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
-      },
-      "isTrusted(address)": {
-        "notice": "trusted addresses that can update target exposure and do others non critical operations"
-      },
-      "maxTokenSlippage(address)": {
-        "notice": "Max slippage when dealing with the Parallelizer"
-      },
-      "parallelizer()": {
-        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
-      },
-      "recoverERC20(address,uint256,address)": {
-        "notice": "Recover ERC20 tokens"
-      },
-      "removeBudget(uint256,address)": {
-        "notice": "Remove budget from the owner and send it to the receiver"
-      },
-      "setMaxSlippage(address,uint96)": {
-        "notice": "Set the max allowed slippage"
-      },
-      "setSwapRouter(address)": {
-        "notice": "Set the swap router"
-      },
-      "setTargetExposure(address,uint64)": {
-        "notice": "Set the target exposure of a yield bearing asset"
-      },
-      "setTokenTransferAddress(address)": {
-        "notice": "Set the token transfer address"
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "notice": "Set the yieldBearingAsset data"
-      },
-      "swapRouter()": {
-        "notice": "address of the router/aggregator"
-      },
-      "toggleTrusted(address)": {
-        "notice": "Toggle the trusted status of an address"
-      },
-      "tokenP()": {
-        "notice": "TokenP handled by the `parallelizer` of interest"
-      },
-      "tokenTransferAddress()": {
-        "notice": "address to approve to transfer tokens to"
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
-      },
-      "yieldBearingData(address)": {
-        "notice": "Data associated to a yield bearing asset"
-      }
-    },
-    "version": 1
-  },
-  "storageLayout": {
-    "storage": [
-      {
-        "astId": 22996,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_authority",
-        "offset": 0,
-        "slot": "0",
-        "type": "t_address"
-      },
-      {
-        "astId": 22998,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_consumingSchedule",
-        "offset": 20,
-        "slot": "0",
-        "type": "t_bool"
-      },
-      {
-        "astId": 8228,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "maxTokenSlippage",
-        "offset": 0,
-        "slot": "1",
-        "type": "t_mapping(t_address,t_uint96)"
-      },
-      {
-        "astId": 8234,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "yieldBearingData",
-        "offset": 0,
-        "slot": "2",
-        "type": "t_mapping(t_address,t_struct(YieldBearingParams)8169_storage)"
-      },
-      {
-        "astId": 8239,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "isTrusted",
-        "offset": 0,
-        "slot": "3",
-        "type": "t_mapping(t_address,t_bool)"
-      },
-      {
-        "astId": 43,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "swapRouter",
-        "offset": 0,
-        "slot": "4",
-        "type": "t_address"
-      },
-      {
-        "astId": 46,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "tokenTransferAddress",
-        "offset": 0,
-        "slot": "5",
-        "type": "t_address"
-      },
-      {
-        "astId": 8955,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "budget",
-        "offset": 0,
-        "slot": "6",
-        "type": "t_mapping(t_address,t_uint256)"
-      }
-    ],
-    "types": {
-      "t_address": {
-        "encoding": "inplace",
-        "label": "address",
-        "numberOfBytes": "20"
-      },
-      "t_bool": {
-        "encoding": "inplace",
-        "label": "bool",
-        "numberOfBytes": "1"
-      },
-      "t_mapping(t_address,t_bool)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => bool)",
-        "numberOfBytes": "32",
-        "value": "t_bool"
-      },
-      "t_mapping(t_address,t_struct(YieldBearingParams)8169_storage)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => struct YieldBearingParams)",
-        "numberOfBytes": "32",
-        "value": "t_struct(YieldBearingParams)8169_storage"
-      },
-      "t_mapping(t_address,t_uint256)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint256)",
-        "numberOfBytes": "32",
-        "value": "t_uint256"
-      },
-      "t_mapping(t_address,t_uint96)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint96)",
-        "numberOfBytes": "32",
-        "value": "t_uint96"
-      },
-      "t_struct(YieldBearingParams)8169_storage": {
-        "encoding": "inplace",
-        "label": "struct YieldBearingParams",
-        "members": [
-          {
-            "astId": 8158,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "asset",
-            "offset": 0,
-            "slot": "0",
-            "type": "t_address"
-          },
-          {
-            "astId": 8160,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "targetExposure",
-            "offset": 20,
-            "slot": "0",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8162,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxExposure",
-            "offset": 0,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8164,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "minExposure",
-            "offset": 8,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8166,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "overrideExposures",
-            "offset": 16,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8168,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxSlippage",
-            "offset": 0,
-            "slot": "2",
-            "type": "t_uint96"
-          }
-        ],
-        "numberOfBytes": "96"
-      },
-      "t_uint256": {
-        "encoding": "inplace",
-        "label": "uint256",
-        "numberOfBytes": "32"
-      },
-      "t_uint64": {
-        "encoding": "inplace",
-        "label": "uint64",
-        "numberOfBytes": "8"
-      },
-      "t_uint96": {
-        "encoding": "inplace",
-        "label": "uint96",
-        "numberOfBytes": "12"
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/deployments/sonic/GenericHarvester_USDp.json b/deployments/sonic/GenericHarvester_USDp.json
deleted file mode 100644
index ec8c813..0000000
--- a/deployments/sonic/GenericHarvester_USDp.json
+++ /dev/null
@@ -1,1124 +0,0 @@
-{
-  "address": "0x120805265fA944834DC6e930De2995768806a9d2",
-  "abi": [
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initialTokenTransferAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialSwapRouter",
-          "type": "address"
-        },
-        {
-          "internalType": "contract ITokenP",
-          "name": "definitivetokenP",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IParallelizer",
-          "name": "definitiveParallelizer",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "initialAuthority",
-          "type": "address"
-        },
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "definitiveFlashloan",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "constructor"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedInvalidAuthority",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        },
-        {
-          "internalType": "uint32",
-          "name": "delay",
-          "type": "uint32"
-        }
-      ],
-      "name": "AccessManagedRequiredDelay",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "caller",
-          "type": "address"
-        }
-      ],
-      "name": "AccessManagedUnauthorized",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "InvalidParam",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrusted",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "NotTrustedOrGuardian",
-      "type": "error"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        }
-      ],
-      "name": "SafeERC20FailedOperation",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "SwapError",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAddress",
-      "type": "error"
-    },
-    {
-      "inputs": [],
-      "name": "ZeroAmount",
-      "type": "error"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "authority",
-          "type": "address"
-        }
-      ],
-      "name": "AuthorityUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "token",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "Recovered",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "SwapRouterUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "TokenTransferAddressUpdated",
-      "type": "event"
-    },
-    {
-      "anonymous": false,
-      "inputs": [
-        {
-          "indexed": false,
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        },
-        {
-          "indexed": false,
-          "internalType": "bool",
-          "name": "status",
-          "type": "bool"
-        }
-      ],
-      "name": "TrustedToggled",
-      "type": "event"
-    },
-    {
-      "inputs": [],
-      "name": "CALLBACK_SUCCESS",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "addBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "authority",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "budget",
-      "outputs": [
-        {
-          "internalType": "uint256",
-          "name": "",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "computeRebalanceAmount",
-      "outputs": [
-        {
-          "internalType": "uint8",
-          "name": "increase",
-          "type": "uint8"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "flashloan",
-      "outputs": [
-        {
-          "internalType": "contract IERC3156FlashLender",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "scale",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "extraData",
-          "type": "bytes"
-        }
-      ],
-      "name": "harvest",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "isConsumingScheduledOp",
-      "outputs": [
-        {
-          "internalType": "bytes4",
-          "name": "",
-          "type": "bytes4"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "isTrusted",
-      "outputs": [
-        {
-          "internalType": "bool",
-          "name": "",
-          "type": "bool"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "maxTokenSlippage",
-      "outputs": [
-        {
-          "internalType": "uint96",
-          "name": "",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "initiator",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "uint256",
-          "name": "fee",
-          "type": "uint256"
-        },
-        {
-          "internalType": "bytes",
-          "name": "data",
-          "type": "bytes"
-        }
-      ],
-      "name": "onFlashLoan",
-      "outputs": [
-        {
-          "internalType": "bytes32",
-          "name": "",
-          "type": "bytes32"
-        }
-      ],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "parallelizer",
-      "outputs": [
-        {
-          "internalType": "contract IParallelizer",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "tokenAddress",
-          "type": "address"
-        },
-        {
-          "internalType": "uint256",
-          "name": "amountToRecover",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "to",
-          "type": "address"
-        }
-      ],
-      "name": "recoverERC20",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "uint256",
-          "name": "amount",
-          "type": "uint256"
-        },
-        {
-          "internalType": "address",
-          "name": "receiver",
-          "type": "address"
-        }
-      ],
-      "name": "removeBudget",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newAuthority",
-          "type": "address"
-        }
-      ],
-      "name": "setAuthority",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint96",
-          "name": "newMaxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setMaxSlippage",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newSwapRouter",
-          "type": "address"
-        }
-      ],
-      "name": "setSwapRouter",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        }
-      ],
-      "name": "setTargetExposure",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "newTokenTransferAddress",
-          "type": "address"
-        }
-      ],
-      "name": "setTokenTransferAddress",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        },
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "name": "setYieldBearingAssetData",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "swapRouter",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "trusted",
-          "type": "address"
-        }
-      ],
-      "name": "toggleTrusted",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenP",
-      "outputs": [
-        {
-          "internalType": "contract ITokenP",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [],
-      "name": "tokenTransferAddress",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "yieldBearingAsset",
-          "type": "address"
-        }
-      ],
-      "name": "updateLimitExposuresYieldAsset",
-      "outputs": [],
-      "stateMutability": "nonpayable",
-      "type": "function"
-    },
-    {
-      "inputs": [
-        {
-          "internalType": "address",
-          "name": "",
-          "type": "address"
-        }
-      ],
-      "name": "yieldBearingData",
-      "outputs": [
-        {
-          "internalType": "address",
-          "name": "asset",
-          "type": "address"
-        },
-        {
-          "internalType": "uint64",
-          "name": "targetExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "maxExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "minExposure",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint64",
-          "name": "overrideExposures",
-          "type": "uint64"
-        },
-        {
-          "internalType": "uint96",
-          "name": "maxSlippage",
-          "type": "uint96"
-        }
-      ],
-      "stateMutability": "view",
-      "type": "function"
-    }
-  ],
-  "transactionHash": "0xdaef90c334810e232fb133c5ab664d331d2271b181c1476ac7cfec619b369e0d",
-  "receipt": {
-    "to": null,
-    "from": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02",
-    "contractAddress": "0x120805265fA944834DC6e930De2995768806a9d2",
-    "transactionIndex": 1,
-    "gasUsed": "2489551",
-    "logsBloom": "0x20000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000200010000000000000040000000000000000000000000000000000000000000010000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000010000008000000000000000008000000000000020000000000000000000000000000000000000000000000010000000000000000000000000000004000100000000000000000000000000000000000000020000010000000000000000008000000000008000000000000000000000000000000",
-    "blockHash": "0xfd87a8e9818d7d35faa73985bf5d5f49c50923521e5c64035ff6d8f29ca14273",
-    "transactionHash": "0xdaef90c334810e232fb133c5ab664d331d2271b181c1476ac7cfec619b369e0d",
-    "logs": [
-      {
-        "transactionIndex": 1,
-        "blockNumber": 35498524,
-        "transactionHash": "0xdaef90c334810e232fb133c5ab664d331d2271b181c1476ac7cfec619b369e0d",
-        "address": "0x120805265fA944834DC6e930De2995768806a9d2",
-        "topics": [
-          "0x2f658b440c35314f52658ea8a740e05b284cdc84dc9ae01e891f21b8933e7cad"
-        ],
-        "data": "0x0000000000000000000000008efb3ded78fbaef2a4efe01e01bbd911e4094b78",
-        "logIndex": 8,
-        "blockHash": "0xfd87a8e9818d7d35faa73985bf5d5f49c50923521e5c64035ff6d8f29ca14273"
-      },
-      {
-        "transactionIndex": 1,
-        "blockNumber": 35498524,
-        "transactionHash": "0xdaef90c334810e232fb133c5ab664d331d2271b181c1476ac7cfec619b369e0d",
-        "address": "0x08417cdb7F52a5021bB4eb6E0deAf3f295c3f182",
-        "topics": [
-          "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
-          "0x000000000000000000000000120805265fa944834dc6e930de2995768806a9d2",
-          "0x0000000000000000000000002cb56df31b909854b01d4b1ead5676cf90e885e7"
-        ],
-        "data": "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff",
-        "logIndex": 9,
-        "blockHash": "0xfd87a8e9818d7d35faa73985bf5d5f49c50923521e5c64035ff6d8f29ca14273"
-      }
-    ],
-    "blockNumber": 35498524,
-    "cumulativeGasUsed": "2653746",
-    "status": 1,
-    "byzantium": true
-  },
-  "args": [
-    "0xaC041Df48dF9791B0654f1Dbbf2CC8450C5f2e9D",
-    "0xaC041Df48dF9791B0654f1Dbbf2CC8450C5f2e9D",
-    "0x08417cdb7F52a5021bB4eb6E0deAf3f295c3f182",
-    "0xBEFBAe2330186F031b469e26283aCc66bb5F8826",
-    "0x8eFb3DED78FbaEF2a4eFe01E01BBD911E4094b78",
-    "0x2cb56dF31b909854B01D4B1EAd5676cf90e885E7"
-  ],
-  "numDeployments": 1,
-  "solcInputHash": "9e6800737641b3b015331b65b5c620c3",
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"maxTokenSlippage\",\"outputs\":[{\"internalType\":\"uint96\",\"name\":\"\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint96\",\"name\":\"newMaxSlippage\",\"type\":\"uint96\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint96\",\"name\":\"maxSlippage\",\"type\":\"uint96\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"Receive a flash loan.\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint96)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericHarvester\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"maxTokenSlippage(address)\":{\"notice\":\"Max slippage when dealing with the Parallelizer\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"setMaxSlippage(address,uint96)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/helpers/GenericHarvester.sol\":\"GenericHarvester\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"},\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        (bool success, bytes memory data) = authority.staticcall(\\n            abi.encodeCall(IAuthority.canCall, (caller, target, selector))\\n        );\\n        if (success) {\\n            if (data.length >= 0x40) {\\n                (immediate, delay) = abi.decode(data, (bool, uint32));\\n            } else if (data.length >= 0x20) {\\n                immediate = abi.decode(data, (bool));\\n            }\\n        }\\n        return (immediate, delay);\\n    }\\n}\\n\",\"keccak256\":\"0xb3875997b0d8705e29aa20fee88e1dfef93df438794ae1ad8ba2eb016a4dd4e4\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity ^0.8.20;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaba93d42cd70e1418782951132d97b31ddce5f50ad81090884b6d0e41caac9d6\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Time} from \\\"../../utils/types/Time.sol\\\";\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `immediate` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x9be2d08a326515805bc9cf6315b7953f8d1ebe88abf48c2d645fb1fa8211a0e2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/IAuthority.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x4cc0766bd7fb7b3bafb70afa2a93b6e313a0baec7a35ad1b57505be7861c1030\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0x9b6b3e7803bc5f2f8cd7ad57db8ac1def61a9930a5a3107df4882e028a9605d7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0xde7e9fd9aee8d4f40772f96bb3b58836cbc6dfc0227014a061947f8821ea9724\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0xce41876e78d1badc0512229b4d14e4daf83bc1003d7f83978d18e0e56f965b9c\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x0b1459615b9b47c2a4eec8e72f23ccc601f1d711f679a1c06b3390459021a341\",\"license\":\"MIT\"},\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x5d19ea24c555cf6a5dbafea9fac57887cc3e72154f3ee8e0a2bf67971811c14b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0xe06a3f08a987af6ad2e1c1e774405d4fe08f1694b67517438b467cecf0da0ef7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x70f2f713b13b7ce4610bcd0ac9fec0f3cc43693b043abcb8dc40a42a726eb330\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x4ea01544758fd2c7045961904686bfe232d2220a04ecaa2d6b08dac17827febf\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x79796192ec90263f21b464d5bc90b777a525971d3de8232be80d9c4f9fb353b8\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            if (c < a) return (false, 0);\\n            return (true, c);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b > a) return (false, 0);\\n            return (true, a - b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n            // benefit is lost if 'b' is also tested.\\n            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n            if (a == 0) return (true, 0);\\n            uint256 c = a * b;\\n            if (c / a != b) return (false, 0);\\n            return (true, c);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b == 0) return (false, 0);\\n            return (true, a / b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            if (b == 0) return (false, 0);\\n            return (true, a % b);\\n        }\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n            // variables such that product = prod1 * 2\\u00b2\\u2075\\u2076 + prod0.\\n            uint256 prod0 = x * y; // Least significant 256 bits of the product\\n            uint256 prod1; // Most significant 256 bits of the product\\n            assembly {\\n                let mm := mulmod(x, y, not(0))\\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\\n            }\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (prod1 == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return prod0 / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= prod1) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [prod1 prod0].\\n            uint256 remainder;\\n            assembly {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                prod1 := sub(prod1, gt(remainder, prod0))\\n                prod0 := sub(prod0, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [prod1 prod0] by twos.\\n                prod0 := div(prod0, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from prod1 into prod0.\\n            prod0 |= prod1 * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and prod1\\n            // is no longer required.\\n            result = prod0 * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        uint256 exp;\\n        unchecked {\\n            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);\\n            value >>= exp;\\n            result += exp;\\n\\n            result += SafeCast.toUint(value > 1);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        uint256 isGt;\\n        unchecked {\\n            isGt = SafeCast.toUint(value > (1 << 128) - 1);\\n            value >>= isGt * 128;\\n            result += isGt * 16;\\n\\n            isGt = SafeCast.toUint(value > (1 << 64) - 1);\\n            value >>= isGt * 64;\\n            result += isGt * 8;\\n\\n            isGt = SafeCast.toUint(value > (1 << 32) - 1);\\n            value >>= isGt * 32;\\n            result += isGt * 4;\\n\\n            isGt = SafeCast.toUint(value > (1 << 16) - 1);\\n            value >>= isGt * 16;\\n            result += isGt * 2;\\n\\n            result += SafeCast.toUint(value > (1 << 8) - 1);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0xa00be322d7db5786750ce0ac7e2f5b633ac30a5ed5fa1ced1e74acfc19acecea\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/types/Time.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/types/Time.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Math} from \\\"../math/Math.sol\\\";\\nimport {SafeCast} from \\\"../math/SafeCast.sol\\\";\\n\\n/**\\n * @dev This library provides helpers for manipulating time-related objects.\\n *\\n * It uses the following types:\\n * - `uint48` for timepoints\\n * - `uint32` for durations\\n *\\n * While the library doesn't provide specific types for timepoints and duration, it does provide:\\n * - a `Delay` type to represent duration that can be programmed to change value automatically at a given point\\n * - additional helper functions\\n */\\nlibrary Time {\\n    using Time for *;\\n\\n    /**\\n     * @dev Get the block timestamp as a Timepoint.\\n     */\\n    function timestamp() internal view returns (uint48) {\\n        return SafeCast.toUint48(block.timestamp);\\n    }\\n\\n    /**\\n     * @dev Get the block number as a Timepoint.\\n     */\\n    function blockNumber() internal view returns (uint48) {\\n        return SafeCast.toUint48(block.number);\\n    }\\n\\n    // ==================================================== Delay =====================================================\\n    /**\\n     * @dev A `Delay` is a uint32 duration that can be programmed to change value automatically at a given point in the\\n     * future. The \\\"effect\\\" timepoint describes when the transitions happens from the \\\"old\\\" value to the \\\"new\\\" value.\\n     * This allows updating the delay applied to some operation while keeping some guarantees.\\n     *\\n     * In particular, the {update} function guarantees that if the delay is reduced, the old delay still applies for\\n     * some time. For example if the delay is currently 7 days to do an upgrade, the admin should not be able to set\\n     * the delay to 0 and upgrade immediately. If the admin wants to reduce the delay, the old delay (7 days) should\\n     * still apply for some time.\\n     *\\n     *\\n     * The `Delay` type is 112 bits long, and packs the following:\\n     *\\n     * ```\\n     *   | [uint48]: effect date (timepoint)\\n     *   |           | [uint32]: value before (duration)\\n     *   \\u2193           \\u2193       \\u2193 [uint32]: value after (duration)\\n     * 0xAAAAAAAAAAAABBBBBBBBCCCCCCCC\\n     * ```\\n     *\\n     * NOTE: The {get} and {withUpdate} functions operate using timestamps. Block number based delays are not currently\\n     * supported.\\n     */\\n    type Delay is uint112;\\n\\n    /**\\n     * @dev Wrap a duration into a Delay to add the one-step \\\"update in the future\\\" feature\\n     */\\n    function toDelay(uint32 duration) internal pure returns (Delay) {\\n        return Delay.wrap(duration);\\n    }\\n\\n    /**\\n     * @dev Get the value at a given timepoint plus the pending value and effect timepoint if there is a scheduled\\n     * change after this timepoint. If the effect timepoint is 0, then the pending value should not be considered.\\n     */\\n    function _getFullAt(\\n        Delay self,\\n        uint48 timepoint\\n    ) private pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        (valueBefore, valueAfter, effect) = self.unpack();\\n        return effect <= timepoint ? (valueAfter, 0, 0) : (valueBefore, valueAfter, effect);\\n    }\\n\\n    /**\\n     * @dev Get the current value plus the pending value and effect timepoint if there is a scheduled change. If the\\n     * effect timepoint is 0, then the pending value should not be considered.\\n     */\\n    function getFull(Delay self) internal view returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        return _getFullAt(self, timestamp());\\n    }\\n\\n    /**\\n     * @dev Get the current value.\\n     */\\n    function get(Delay self) internal view returns (uint32) {\\n        (uint32 delay, , ) = self.getFull();\\n        return delay;\\n    }\\n\\n    /**\\n     * @dev Update a Delay object so that it takes a new duration after a timepoint that is automatically computed to\\n     * enforce the old delay at the moment of the update. Returns the updated Delay object and the timestamp when the\\n     * new delay becomes effective.\\n     */\\n    function withUpdate(\\n        Delay self,\\n        uint32 newValue,\\n        uint32 minSetback\\n    ) internal view returns (Delay updatedDelay, uint48 effect) {\\n        uint32 value = self.get();\\n        uint32 setback = uint32(Math.max(minSetback, value > newValue ? value - newValue : 0));\\n        effect = timestamp() + setback;\\n        return (pack(value, newValue, effect), effect);\\n    }\\n\\n    /**\\n     * @dev Split a delay into its components: valueBefore, valueAfter and effect (transition timepoint).\\n     */\\n    function unpack(Delay self) internal pure returns (uint32 valueBefore, uint32 valueAfter, uint48 effect) {\\n        uint112 raw = Delay.unwrap(self);\\n\\n        valueAfter = uint32(raw);\\n        valueBefore = uint32(raw >> 32);\\n        effect = uint48(raw >> 64);\\n\\n        return (valueBefore, valueAfter, effect);\\n    }\\n\\n    /**\\n     * @dev pack the components into a Delay object.\\n     */\\n    function pack(uint32 valueBefore, uint32 valueAfter, uint48 effect) internal pure returns (Delay) {\\n        return Delay.wrap((uint112(effect) << 64) | (uint112(valueBefore) << 32) | uint112(valueAfter));\\n    }\\n}\\n\",\"keccak256\":\"0x36776530f012618bc7526ceb28e77b85e582cb12d9b9466a71d4bd6bf952e4cc\",\"license\":\"MIT\"},\"contracts/helpers/BaseHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IHarvester.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer\\n  uint96 maxSlippage;\\n}\\n\\n/// @title BaseHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a harvester that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseHarvester is IHarvester, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Max slippage when dealing with the Parallelizer\\n  mapping(address => uint96) public maxTokenSlippage;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage > 1e9) revert InvalidParam();\\n    maxTokenSlippage[yieldBearingAsset] = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x82e2ae57997043160d7529488b34591c710cd74e267213b61009daa96e9eeaaf\",\"license\":\"GPL-3.0\"},\"contracts/helpers/GenericHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseHarvester, YieldBearingParams } from \\\"./BaseHarvester.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for anyone to permissionlessly adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericHarvester is BaseHarvester, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseHarvester(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this) || fee != 0) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n\\n    // Swap to tokenIn\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x604c4f9c755b2eb704dc15ba59046201c0258134ef2fbe15a529c510c68cb40a\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0xaa9eba6ee7770d6146fedbfef07ad10ff09524692319ca0cc32abfa64a2b597b\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IHarvester.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IHarvester\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IHarvester {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint96 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0d4e8fee737f4f747060a3c5044c8cb2f153faa228ad37a661a659ca62aab055\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IParallelizer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IParallelizer.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper\\n{ }\\n\",\"keccak256\":\"0x8bd964110c6a122bdb6cf58a194a97c894900237ebd7f3b11e2f43c6ee56ae7c\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0xb3522ee0380b321c64d02bf2db2acb658d8b314b811dd54b6a718d6708b5fb21\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Changes the pause status for mint or burn transactions for `collateral`\\n  function togglePause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xc3fb2012e7c2f97ae93b12276afc4293aaeb97a6fe4d60109acaa94ef6945575\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0x47e4b2742a51b82b9df72fb681335affe8519f4114fb540cd29d8f48ed182ffd\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType;\\n}\\n// Whether an address is whitelisted for a specific whitelist type\\n\",\"keccak256\":\"0x3f4313dd110dbe390038320b2d3cf24dcbe9b75cd9573e7f048f7233c02dd227\",\"license\":\"BUSL-1.1\"},\"contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror Paused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\n\",\"keccak256\":\"0x1e2f6812ef78e948e5155d32213b52afff8c0ba5463d18bee10694efbf886130\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
-  "bytecode": "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",
-  "deployedBytecode": "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",
-  "devdoc": {
-    "author": "Cooper Labs",
-    "custom:contact": "security@cooperlabs.xyz",
-    "details": "Generic contract for anyone to permissionlessly adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
-    "errors": {
-      "SafeERC20FailedOperation(address)": [
-        {
-          "details": "An operation with an ERC-20 token failed."
-        }
-      ]
-    },
-    "events": {
-      "AuthorityUpdated(address)": {
-        "details": "Authority that manages this contract was updated."
-      }
-    },
-    "kind": "dev",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to add to the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "authority()": {
-        "details": "Returns the current authority."
-      },
-      "computeRebalanceAmount(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        },
-        "returns": {
-          "amount": "amount to be rebalanced",
-          "increase": "whether the exposure should be increased"
-        }
-      },
-      "harvest(address,uint256,bytes)": {
-        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippage"
-      },
-      "isConsumingScheduledOp()": {
-        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
-      },
-      "onFlashLoan(address,address,uint256,uint256,bytes)": {
-        "details": "Receive a flash loan.",
-        "params": {
-          "amount": "The amount of tokens lent.",
-          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
-          "fee": "The additional amount of tokens to repay.",
-          "initiator": "The initiator of the loan.",
-          "token": "The loan currency."
-        },
-        "returns": {
-          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
-        }
-      },
-      "recoverERC20(address,uint256,address)": {
-        "params": {
-          "amountToRecover": "amount to recover",
-          "to": "address to send the recovered tokens",
-          "tokenAddress": "address of the token to recover"
-        }
-      },
-      "removeBudget(uint256,address)": {
-        "params": {
-          "amount": "amount of tokenP to remove from the budget",
-          "receiver": "address of the receiver"
-        }
-      },
-      "setAuthority(address)": {
-        "details": "Transfers control to a new authority. The caller must be the current authority."
-      },
-      "setMaxSlippage(address,uint96)": {
-        "params": {
-          "newMaxSlippage": "new max allowed slippage"
-        }
-      },
-      "setSwapRouter(address)": {
-        "params": {
-          "newSwapRouter": "address of the swap router"
-        }
-      },
-      "setTargetExposure(address,uint64)": {
-        "params": {
-          "targetExposure": "target exposure to the yield bearing asset used",
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      },
-      "setTokenTransferAddress(address)": {
-        "params": {
-          "newTokenTransferAddress": "address of the token transfer contract"
-        }
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "params": {
-          "asset": "address of the asset",
-          "maxExposure": "maximum exposure within the Parallelizer to the asset",
-          "minExposure": "minimum exposure within the Parallelizer to the asset",
-          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
-          "targetExposure": "target exposure to the yieldBearingAsset asset used",
-          "yieldBearingAsset": "address of the yieldBearingAsset"
-        }
-      },
-      "toggleTrusted(address)": {
-        "params": {
-          "trusted": "address to toggle the trusted status"
-        }
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "params": {
-          "yieldBearingAsset": "address of the yield bearing asset"
-        }
-      }
-    },
-    "title": "GenericHarvester",
-    "version": 1
-  },
-  "userdoc": {
-    "events": {
-      "SwapRouterUpdated(address)": {
-        "notice": "Event emitted when the swap router is updated"
-      },
-      "TokenTransferAddressUpdated(address)": {
-        "notice": "Event emitted when the token proxy is updated"
-      }
-    },
-    "kind": "user",
-    "methods": {
-      "addBudget(uint256,address)": {
-        "notice": "Add budget to be spent by the receiver during the flashloan"
-      },
-      "budget(address)": {
-        "notice": "Budget of tokenP available for each users"
-      },
-      "computeRebalanceAmount(address)": {
-        "notice": "Compute the amount needed to rebalance the Parallelizer"
-      },
-      "flashloan()": {
-        "notice": "Parallel stablecoin flashloan contract"
-      },
-      "harvest(address,uint256,bytes)": {
-        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
-      },
-      "isTrusted(address)": {
-        "notice": "trusted addresses that can update target exposure and do others non critical operations"
-      },
-      "maxTokenSlippage(address)": {
-        "notice": "Max slippage when dealing with the Parallelizer"
-      },
-      "parallelizer()": {
-        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
-      },
-      "recoverERC20(address,uint256,address)": {
-        "notice": "Recover ERC20 tokens"
-      },
-      "removeBudget(uint256,address)": {
-        "notice": "Remove budget from the owner and send it to the receiver"
-      },
-      "setMaxSlippage(address,uint96)": {
-        "notice": "Set the max allowed slippage"
-      },
-      "setSwapRouter(address)": {
-        "notice": "Set the swap router"
-      },
-      "setTargetExposure(address,uint64)": {
-        "notice": "Set the target exposure of a yield bearing asset"
-      },
-      "setTokenTransferAddress(address)": {
-        "notice": "Set the token transfer address"
-      },
-      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint96)": {
-        "notice": "Set the yieldBearingAsset data"
-      },
-      "swapRouter()": {
-        "notice": "address of the router/aggregator"
-      },
-      "toggleTrusted(address)": {
-        "notice": "Toggle the trusted status of an address"
-      },
-      "tokenP()": {
-        "notice": "TokenP handled by the `parallelizer` of interest"
-      },
-      "tokenTransferAddress()": {
-        "notice": "address to approve to transfer tokens to"
-      },
-      "updateLimitExposuresYieldAsset(address)": {
-        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
-      },
-      "yieldBearingData(address)": {
-        "notice": "Data associated to a yield bearing asset"
-      }
-    },
-    "version": 1
-  },
-  "storageLayout": {
-    "storage": [
-      {
-        "astId": 22996,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_authority",
-        "offset": 0,
-        "slot": "0",
-        "type": "t_address"
-      },
-      {
-        "astId": 22998,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "_consumingSchedule",
-        "offset": 20,
-        "slot": "0",
-        "type": "t_bool"
-      },
-      {
-        "astId": 8228,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "maxTokenSlippage",
-        "offset": 0,
-        "slot": "1",
-        "type": "t_mapping(t_address,t_uint96)"
-      },
-      {
-        "astId": 8234,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "yieldBearingData",
-        "offset": 0,
-        "slot": "2",
-        "type": "t_mapping(t_address,t_struct(YieldBearingParams)8169_storage)"
-      },
-      {
-        "astId": 8239,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "isTrusted",
-        "offset": 0,
-        "slot": "3",
-        "type": "t_mapping(t_address,t_bool)"
-      },
-      {
-        "astId": 43,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "swapRouter",
-        "offset": 0,
-        "slot": "4",
-        "type": "t_address"
-      },
-      {
-        "astId": 46,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "tokenTransferAddress",
-        "offset": 0,
-        "slot": "5",
-        "type": "t_address"
-      },
-      {
-        "astId": 8955,
-        "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-        "label": "budget",
-        "offset": 0,
-        "slot": "6",
-        "type": "t_mapping(t_address,t_uint256)"
-      }
-    ],
-    "types": {
-      "t_address": {
-        "encoding": "inplace",
-        "label": "address",
-        "numberOfBytes": "20"
-      },
-      "t_bool": {
-        "encoding": "inplace",
-        "label": "bool",
-        "numberOfBytes": "1"
-      },
-      "t_mapping(t_address,t_bool)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => bool)",
-        "numberOfBytes": "32",
-        "value": "t_bool"
-      },
-      "t_mapping(t_address,t_struct(YieldBearingParams)8169_storage)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => struct YieldBearingParams)",
-        "numberOfBytes": "32",
-        "value": "t_struct(YieldBearingParams)8169_storage"
-      },
-      "t_mapping(t_address,t_uint256)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint256)",
-        "numberOfBytes": "32",
-        "value": "t_uint256"
-      },
-      "t_mapping(t_address,t_uint96)": {
-        "encoding": "mapping",
-        "key": "t_address",
-        "label": "mapping(address => uint96)",
-        "numberOfBytes": "32",
-        "value": "t_uint96"
-      },
-      "t_struct(YieldBearingParams)8169_storage": {
-        "encoding": "inplace",
-        "label": "struct YieldBearingParams",
-        "members": [
-          {
-            "astId": 8158,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "asset",
-            "offset": 0,
-            "slot": "0",
-            "type": "t_address"
-          },
-          {
-            "astId": 8160,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "targetExposure",
-            "offset": 20,
-            "slot": "0",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8162,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxExposure",
-            "offset": 0,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8164,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "minExposure",
-            "offset": 8,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8166,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "overrideExposures",
-            "offset": 16,
-            "slot": "1",
-            "type": "t_uint64"
-          },
-          {
-            "astId": 8168,
-            "contract": "contracts/helpers/GenericHarvester.sol:GenericHarvester",
-            "label": "maxSlippage",
-            "offset": 0,
-            "slot": "2",
-            "type": "t_uint96"
-          }
-        ],
-        "numberOfBytes": "96"
-      },
-      "t_uint256": {
-        "encoding": "inplace",
-        "label": "uint256",
-        "numberOfBytes": "32"
-      },
-      "t_uint64": {
-        "encoding": "inplace",
-        "label": "uint64",
-        "numberOfBytes": "8"
-      },
-      "t_uint96": {
-        "encoding": "inplace",
-        "label": "uint96",
-        "numberOfBytes": "12"
-      }
-    }
-  }
-}
\ No newline at end of file
diff --git a/generated/abis/IHarvester.d.ts b/generated/abis/IRebalancer.d.ts
similarity index 95%
rename from generated/abis/IHarvester.d.ts
rename to generated/abis/IRebalancer.d.ts
index 971f5f1..71bebfc 100644
--- a/generated/abis/IHarvester.d.ts
+++ b/generated/abis/IRebalancer.d.ts
@@ -1,4 +1,4 @@
-export type Abi_IHarvester = [
+export type Abi_IRebalancer = [
   {
     "inputs": [
       {
@@ -97,4 +97,4 @@ export type Abi_IHarvester = [
     "type": "function"
   }
 ];
-export declare const Abi_IHarvester: Abi_IHarvester;
+export declare const Abi_IRebalancer: Abi_IRebalancer;
diff --git a/generated/abis/IHarvester.js b/generated/abis/IRebalancer.js
similarity index 97%
rename from generated/abis/IHarvester.js
rename to generated/abis/IRebalancer.js
index 6c01bbf..f69a3a1 100644
--- a/generated/abis/IHarvester.js
+++ b/generated/abis/IRebalancer.js
@@ -1,4 +1,4 @@
-export const Abi_IHarvester = /** @type {const} **/ ([
+export const Abi_IRebalancer = /** @type {const} **/ ([
   {
     "inputs": [
       {
diff --git a/generated/abis/index.d.ts b/generated/abis/index.d.ts
index a554fcb..9586460 100644
--- a/generated/abis/index.d.ts
+++ b/generated/abis/index.d.ts
@@ -5,11 +5,11 @@ export {Abi_IDiamondCut as IDiamondCut} from "./IDiamondCut.js"
 export {Abi_IDiamondEtherscan as IDiamondEtherscan} from "./IDiamondEtherscan.js"
 export {Abi_IDiamondLoupe as IDiamondLoupe} from "./IDiamondLoupe.js"
 export {Abi_IGetters as IGetters} from "./IGetters.js"
-export {Abi_IHarvester as IHarvester} from "./IHarvester.js"
 export {Abi_IManager as IManager} from "./IManager.js"
 export {Abi_IParallelizer as IParallelizer} from "./IParallelizer.js"
 export {Abi_IParallelizerOracle as IParallelizerOracle} from "./IParallelizerOracle.js"
 export {Abi_IPool as IPool} from "./IPool.js"
+export {Abi_IRebalancer as IRebalancer} from "./IRebalancer.js"
 export {Abi_IRedeemer as IRedeemer} from "./IRedeemer.js"
 export {Abi_IRewardHandler as IRewardHandler} from "./IRewardHandler.js"
 export {Abi_ISavings as ISavings} from "./ISavings.js"
diff --git a/generated/abis/index.js b/generated/abis/index.js
index a554fcb..9586460 100644
--- a/generated/abis/index.js
+++ b/generated/abis/index.js
@@ -5,11 +5,11 @@ export {Abi_IDiamondCut as IDiamondCut} from "./IDiamondCut.js"
 export {Abi_IDiamondEtherscan as IDiamondEtherscan} from "./IDiamondEtherscan.js"
 export {Abi_IDiamondLoupe as IDiamondLoupe} from "./IDiamondLoupe.js"
 export {Abi_IGetters as IGetters} from "./IGetters.js"
-export {Abi_IHarvester as IHarvester} from "./IHarvester.js"
 export {Abi_IManager as IManager} from "./IManager.js"
 export {Abi_IParallelizer as IParallelizer} from "./IParallelizer.js"
 export {Abi_IParallelizerOracle as IParallelizerOracle} from "./IParallelizerOracle.js"
 export {Abi_IPool as IPool} from "./IPool.js"
+export {Abi_IRebalancer as IRebalancer} from "./IRebalancer.js"
 export {Abi_IRedeemer as IRedeemer} from "./IRedeemer.js"
 export {Abi_IRewardHandler as IRewardHandler} from "./IRewardHandler.js"
 export {Abi_ISavings as ISavings} from "./ISavings.js"

From dab8270df9df8676dae6a2c31a85adc4241de532 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 10:55:54 +0300
Subject: [PATCH 08/38] docs(rebalancer): restore upstream names in the Angle
 attribution

The rename also rewrote the references to Angle's own files, so the
attribution named contracts that do not exist upstream and the links no
longer resolved. Angle's files are BaseHarvester, GenericHarvester and
MultiBlockHarvester, and the notices now name them again.

BaseRebalancer and GenericRebalancer are marked as substantially
modified, which is accurate for both; MultiBlockRebalancer is unchanged
beyond its name and keeps the plain notice.
---
 contracts/helpers/BaseRebalancer.sol       | 4 ++--
 contracts/helpers/GenericRebalancer.sol    | 4 ++--
 contracts/helpers/MultiBlockRebalancer.sol | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/contracts/helpers/BaseRebalancer.sol b/contracts/helpers/BaseRebalancer.sol
index ca74d53..9ee9da5 100644
--- a/contracts/helpers/BaseRebalancer.sol
+++ b/contracts/helpers/BaseRebalancer.sol
@@ -30,8 +30,8 @@ struct YieldBearingParams {
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
 /// @dev Abstract contract for a rebalancer that aims at rebalancing a Parallelizer
-/// @dev This contract is an authorized fork of Angle's BaseRebalancer contract:
-/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseRebalancer.sol
+/// @dev This contract is an authorized fork of Angle's BaseHarvester contract, substantially modified:
+/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol
 abstract contract BaseRebalancer is IRebalancer, AccessManaged {
   using SafeERC20 for IERC20;
 
diff --git a/contracts/helpers/GenericRebalancer.sol b/contracts/helpers/GenericRebalancer.sol
index 32dd100..dec0ebe 100644
--- a/contracts/helpers/GenericRebalancer.sol
+++ b/contracts/helpers/GenericRebalancer.sol
@@ -26,8 +26,8 @@ enum SwapType {
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
 /// @dev Generic contract for trusted callers to adjust the reserves of Angle Parallelizer
-/// @dev This contract is an authorized fork of Angle's GenericRebalancer contract:
-/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericRebalancer.sol
+/// @dev This contract is an authorized fork of Angle's GenericHarvester contract, substantially modified:
+/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol
 contract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapper {
   using SafeCast for uint256;
   using SafeERC20 for IERC20;
diff --git a/contracts/helpers/MultiBlockRebalancer.sol b/contracts/helpers/MultiBlockRebalancer.sol
index d8b9697..aa1166a 100644
--- a/contracts/helpers/MultiBlockRebalancer.sol
+++ b/contracts/helpers/MultiBlockRebalancer.sol
@@ -17,8 +17,8 @@ import "../utils/Constants.sol";
 /// @author Cooper Labs
 /// @custom:contact security@cooperlabs.xyz
 /// @dev Contract to harvest yield from multiple yield bearing assets in multiple blocks transactions
-/// @dev This contract is an authorized fork of Angle's MultiBlockRebalancer contract:
-/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/MultiBlockRebalancer.sol
+/// @dev This contract is an authorized fork of Angle's MultiBlockHarvester contract:
+/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/MultiBlockHarvester.sol
 contract MultiBlockRebalancer is BaseRebalancer {
   using SafeERC20 for IERC20;
   using Math for uint256;

From 87a788178f6c76b1778c3cf471baf3718535eef5 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 11:09:18 +0300
Subject: [PATCH 09/38] fix(rebalancer): return unconsumed router input instead
 of reverting

The previous check rejected any route that consumed less than it was
offered. That is too strict: the input is sized on chain from the live
Parallelizer state while the router calldata is built off chain, so the
two cannot be expected to match exactly, and any upward drift between
the keeper's simulation and inclusion would have failed the rebalance.

The remainder is now swapped back through the Parallelizer and added to
the settlement, so it reaches the initiating caller's budget rather than
being stranded. The router allowance is also cleared after the swap so a
partial fill leaves nothing standing.

Refines Bailsec Core Issue_07.
---
 contracts/helpers/GenericRebalancer.sol | 28 ++++++++++++++++++++-----
 contracts/utils/Errors.sol              |  1 -
 2 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/contracts/helpers/GenericRebalancer.sol b/contracts/helpers/GenericRebalancer.sol
index dec0ebe..fa40258 100644
--- a/contracts/helpers/GenericRebalancer.sol
+++ b/contracts/helpers/GenericRebalancer.sol
@@ -163,14 +163,12 @@ contract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapp
     // Swap to tokenOut
     amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);
 
-    // A partial fill would leave both the unspent input and its router allowance on this contract
-    if (IERC20(tokenIn).balanceOf(address(this)) > tokenInBalanceBefore) {
-      revert RouterDidNotConsumeAllTokens();
-    }
-
     _adjustAllowance(tokenOut, address(parallelizer), amountOut);
     uint256 amountStableOut =
       parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);
+
+    amountStableOut += _recoverResidualInput(tokenIn, tokenInBalanceBefore);
+
     if (amount > amountStableOut) {
       budget[sender] -= amount - amountStableOut; // Will revert if not enough funds
     } else if (amountStableOut > amount) {
@@ -228,6 +226,24 @@ contract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapp
     );
   }
 
+  /**
+   * @dev Returns any input the route did not consume to the Parallelizer
+   * @param tokenIn address of the token offered to the route
+   * @param balanceBefore balance of `tokenIn` held before the operation
+   * @return the tokenP obtained from the remainder, zero when the route consumed everything
+   *
+   * Router calldata is built off chain while the input is sized on chain, so a route can consume
+   * less than was offered. Returning the remainder keeps it inside the Parallelizer's accounting
+   * instead of stranding it here, and it settles with the rest of the operation.
+   */
+  function _recoverResidualInput(address tokenIn, uint256 balanceBefore) internal returns (uint256) {
+    uint256 balanceAfter = IERC20(tokenIn).balanceOf(address(this));
+    if (balanceAfter <= balanceBefore) return 0;
+    uint256 residual = balanceAfter - balanceBefore;
+    _adjustAllowance(tokenIn, address(parallelizer), residual);
+    return parallelizer.swapExactInput(residual, 0, tokenIn, address(tokenP), address(this), block.timestamp);
+  }
+
   function _swapToTokenOut(
     uint256 typeAction,
     address tokenIn,
@@ -271,6 +287,8 @@ contract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapp
     uint256[] memory amounts = new uint256[](1);
     amounts[0] = amount;
     _swap(tokens, callDatas, amounts);
+    // A route that consumed less than offered would otherwise leave the difference approved
+    IERC20(tokenIn).forceApprove(tokenTransferAddress, 0);
 
     return IERC20(tokenOut).balanceOf(address(this)) - balance;
   }
diff --git a/contracts/utils/Errors.sol b/contracts/utils/Errors.sol
index 39b1db1..6ee3525 100644
--- a/contracts/utils/Errors.sol
+++ b/contracts/utils/Errors.sol
@@ -55,7 +55,6 @@ error ZeroAddress();
 error ZeroAmount();
 error ZeroSurplusAmount();
 error SwapError();
-error RouterDidNotConsumeAllTokens();
 error SlippageTooHigh();
 error InsufficientFunds();
 error Undercollateralized();

From 7497d1cbf19d1b1ac6d9be376bdc8c5aac12103c Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 11:18:15 +0300
Subject: [PATCH 10/38] test(rebalancer): cover the harvest flash loan
 settlement path

onFlashLoan had no coverage at all, so neither the router leg nor the
budget settlement was exercised. A zero-fee ERC-3156 lender mock lets the
existing MockRouter drive a route that consumes less input than it was
offered.

Without the recovery the run leaves 781.198 of the input stranded on the
rebalancer; the test asserts nothing is left, no router allowance
survives, and the recovered value reaches the caller's budget.
---
 tests/mock/MockFlashLoan.sol | 37 ++++++++++++++++++
 tests/units/Rebalancer.t.sol | 76 ++++++++++++++++++++++++++++++++++++
 2 files changed, 113 insertions(+)
 create mode 100644 tests/mock/MockFlashLoan.sol

diff --git a/tests/mock/MockFlashLoan.sol b/tests/mock/MockFlashLoan.sol
new file mode 100644
index 0000000..b2ac3f0
--- /dev/null
+++ b/tests/mock/MockFlashLoan.sol
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Unlicensed
+pragma solidity 0.8.28;
+
+import { IERC3156FlashBorrower } from "@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { MockTokenPermit } from "./MockTokenPermit.sol";
+
+/// @dev Zero-fee ERC-3156 lender: mints the principal to the borrower and pulls it back through the
+/// allowance the borrower granted, mirroring FlashParallelToken closely enough for the rebalancer.
+contract MockFlashLoan {
+  bytes32 internal constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
+
+  function maxFlashLoan(address) external pure returns (uint256) {
+    return type(uint256).max;
+  }
+
+  function flashFee(address, uint256) external pure returns (uint256) {
+    return 0;
+  }
+
+  function flashLoan(
+    IERC3156FlashBorrower receiver,
+    address token,
+    uint256 amount,
+    bytes calldata data
+  )
+    external
+    returns (bool)
+  {
+    MockTokenPermit(token).mint(address(receiver), amount);
+    require(receiver.onFlashLoan(msg.sender, token, amount, 0, data) == CALLBACK_SUCCESS, "bad callback");
+    IERC20(token).transferFrom(address(receiver), address(this), amount);
+    MockTokenPermit(token).burn(address(this), amount);
+    return true;
+  }
+}
diff --git a/tests/units/Rebalancer.t.sol b/tests/units/Rebalancer.t.sol
index 7312797..00f0244 100644
--- a/tests/units/Rebalancer.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -3,6 +3,13 @@
 pragma solidity 0.8.28;
 
 import { MultiBlockRebalancer } from "contracts/helpers/MultiBlockRebalancer.sol";
+import { GenericRebalancer, SwapType } from "contracts/helpers/GenericRebalancer.sol";
+import { IERC3156FlashLender } from "@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { MockRouter } from "../mock/MockRouter.sol";
+import { MockFlashLoan } from "../mock/MockFlashLoan.sol";
+import { MockTokenPermit } from "../mock/MockTokenPermit.sol";
 import { IParallelizer } from "contracts/interfaces/IParallelizer.sol";
 import "contracts/utils/Constants.sol";
 import "contracts/utils/Errors.sol" as Errors;
@@ -51,3 +58,72 @@ contract Test_Rebalancer_MaxSlippage is Fixture {
     rebalancer.setMaxSlippage(yieldBearingAsset, 1e7);
   }
 }
+
+
+contract Test_Rebalancer_ResidualInput is Fixture {
+  GenericRebalancer internal rebalancer;
+  MockRouter internal router;
+  MockFlashLoan internal lender;
+
+  function setUp() public override {
+    super.setUp();
+
+    router = new MockRouter();
+    lender = new MockFlashLoan();
+    rebalancer = new GenericRebalancer(
+      address(router), address(router), tokenP, parallelizer, address(accessManager), IERC3156FlashLender(address(lender))
+    );
+
+    vm.startPrank(governor);
+    accessManager.setTargetFunctionRole(
+      address(rebalancer), getGuardianBaseRebalancerSelectorAccess(), GUARDIAN_ROLE
+    );
+    accessManager.grantRole(GUARDIAN_ROLE, guardian, 0);
+    vm.stopPrank();
+
+    // eurY is the yield bearing asset, eurA its underlying. Target exposure well below the live one
+    // so the rebalance decreases eurY and the router leg runs with eurY as the input.
+    vm.startPrank(guardian);
+    rebalancer.toggleTrusted(alice);
+    rebalancer.setYieldBearingAssetData(address(eurY), address(eurA), 2e8, 1e7, 9e8, 1, 5e8);
+    vm.stopPrank();
+
+    _mintCollateral(address(eurY), 100_000 ether);
+    _mintCollateral(address(eurA), 1000 * BASE_6);
+
+    // The router needs the output leg to hand back, and alice a budget to settle against
+    deal(address(eurA), address(router), 1_000_000 * BASE_6);
+    deal(address(tokenP), alice, 100_000 ether);
+    vm.startPrank(alice);
+    IERC20(address(tokenP)).approve(address(rebalancer), type(uint256).max);
+    rebalancer.addBudget(50_000 ether, alice);
+    vm.stopPrank();
+  }
+
+  function _mintCollateral(address collateral, uint256 amount) internal {
+    deal(collateral, governor, amount);
+    vm.startPrank(governor);
+    IERC20(collateral).approve(address(parallelizer), amount);
+    parallelizer.swapExactInput(amount, 0, collateral, address(tokenP), governor, block.timestamp + 1 hours);
+    vm.stopPrank();
+  }
+
+  /// @dev The route consumes less input than it was offered: the remainder must come back rather
+  /// than sit on the rebalancer, and no router allowance may survive the call.
+  function test_Harvest_ReturnsInputTheRouteDidNotConsume() public {
+    uint256 consumed = 1 ether;
+    bytes memory swapData = abi.encodeWithSelector(
+      MockRouter.swap.selector, consumed, address(eurY), 5000 * BASE_6, address(eurA)
+    );
+
+    uint256 budgetBefore = rebalancer.budget(alice);
+
+    vm.prank(alice);
+    rebalancer.harvest(address(eurY), 1e7, abi.encode(SwapType.SWAP, swapData));
+
+    assertEq(IERC20(address(eurY)).balanceOf(address(rebalancer)), 0, "input left stranded on the rebalancer");
+    assertEq(IERC20(address(eurY)).allowance(address(rebalancer), address(router)), 0, "router allowance survived");
+    // The recovered input settles with the operation, so the surplus reaches the initiating caller
+    assertGt(rebalancer.budget(alice), budgetBefore, "settlement surplus not credited");
+  }
+}

From f57482c66f646b9455074a7e6e7d03b3f82f2432 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 11:30:57 +0300
Subject: [PATCH 11/38] fix(rebalancer): revoke allowances a configuration
 rotation leaves behind

Rebalancing grants unlimited allowances and never reduces them, while
rotating a yield bearing asset or a deposit address only overwrote the
configuration. The outgoing spender kept authority over any of that token
the contract later held, for the rest of the contract's life.

Both rotations now revoke the approval they made obsolete, and governance
gets resetAllowance as the escape hatch for anything else, as recommended.

Closes Bailsec Core Issue_02.
---
 contracts/helpers/BaseRebalancer.sol       | 21 ++++++
 contracts/helpers/MultiBlockRebalancer.sol |  7 ++
 generated/abis/BaseRebalancer.d.ts         | 37 +++++++++++
 generated/abis/BaseRebalancer.js           | 37 +++++++++++
 generated/abis/GenericRebalancer.d.ts      | 42 ++++++++++--
 generated/abis/GenericRebalancer.js        | 42 ++++++++++--
 generated/abis/MultiBlockRebalancer.d.ts   | 37 +++++++++++
 generated/abis/MultiBlockRebalancer.js     | 37 +++++++++++
 scripts/SetGenericRebalancerRoles.s.sol    |  3 +-
 tests/units/Rebalancer.t.sol               | 75 ++++++++++++++++++++++
 tests/utils/ConfigAccessManager.sol        |  3 +-
 11 files changed, 329 insertions(+), 12 deletions(-)

diff --git a/contracts/helpers/BaseRebalancer.sol b/contracts/helpers/BaseRebalancer.sol
index 9ee9da5..b9d22a6 100644
--- a/contracts/helpers/BaseRebalancer.sol
+++ b/contracts/helpers/BaseRebalancer.sol
@@ -78,6 +78,7 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
 
   event Recovered(address token, uint256 amount, address to);
   event TrustedToggled(address trusted, bool status);
+  event AllowanceReset(address indexed token, address indexed spender);
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                        CONSTRUCTOR
@@ -163,6 +164,19 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
     IERC20(tokenAddress).safeTransfer(to, amountToRecover);
   }
 
+  /**
+   * @notice Set an allowance this contract granted back to zero
+   * @param token address of the token
+   * @param spender address losing the allowance
+   * @dev Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing
+   * asset's configuration revokes the approvals it created, but this covers a spender that became
+   * untrusted for any other reason.
+   */
+  function resetAllowance(address token, address spender) external restricted {
+    IERC20(token).forceApprove(spender, 0);
+    emit AllowanceReset(token, spender);
+  }
+
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                         TRUSTED FUNCTIONS
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
@@ -244,6 +258,13 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
     virtual
   {
     YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];
+    address previousAsset = yieldBearingInfo.asset;
+    // Allowances are granted without expiry, so the outgoing asset would keep the yield bearing
+    // vault authorised over any of it later held here
+    if (previousAsset != address(0) && previousAsset != asset) {
+      IERC20(previousAsset).forceApprove(yieldBearingAsset, 0);
+      emit AllowanceReset(previousAsset, yieldBearingAsset);
+    }
     yieldBearingInfo.asset = asset;
     if (targetExposure >= 1e9) revert InvalidParam();
     if (maxSlippage >= 1e9) revert InvalidParam();
diff --git a/contracts/helpers/MultiBlockRebalancer.sol b/contracts/helpers/MultiBlockRebalancer.sol
index aa1166a..8edd3f5 100644
--- a/contracts/helpers/MultiBlockRebalancer.sol
+++ b/contracts/helpers/MultiBlockRebalancer.sol
@@ -52,6 +52,13 @@ contract MultiBlockRebalancer is BaseRebalancer {
    * @param newDepositAddress address to deposit to receive yieldBearingAsset
    */
   function setYieldBearingToDepositAddress(address yieldBearingAsset, address newDepositAddress) external restricted {
+    address previousDepositAddress = yieldBearingToDepositAddress[yieldBearingAsset];
+    address asset = yieldBearingData[yieldBearingAsset].asset;
+    // The outgoing deposit address would otherwise keep its allowance over the underlying asset
+    if (previousDepositAddress != address(0) && previousDepositAddress != newDepositAddress && asset != address(0)) {
+      IERC20(asset).forceApprove(previousDepositAddress, 0);
+      emit AllowanceReset(asset, previousDepositAddress);
+    }
     yieldBearingToDepositAddress[yieldBearingAsset] = newDepositAddress;
   }
 
diff --git a/generated/abis/BaseRebalancer.d.ts b/generated/abis/BaseRebalancer.d.ts
index c2b2c58..c0b1549 100644
--- a/generated/abis/BaseRebalancer.d.ts
+++ b/generated/abis/BaseRebalancer.d.ts
@@ -58,6 +58,25 @@ export type Abi_BaseRebalancer = [
     "name": "SafeERC20FailedOperation",
     "type": "error"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "AllowanceReset",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -243,6 +262,24 @@ export type Abi_BaseRebalancer = [
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "resetAllowance",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/BaseRebalancer.js b/generated/abis/BaseRebalancer.js
index 9fbc394..01d033e 100644
--- a/generated/abis/BaseRebalancer.js
+++ b/generated/abis/BaseRebalancer.js
@@ -58,6 +58,25 @@ export const Abi_BaseRebalancer = /** @type {const} **/ ([
     "name": "SafeERC20FailedOperation",
     "type": "error"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "AllowanceReset",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -243,6 +262,24 @@ export const Abi_BaseRebalancer = /** @type {const} **/ ([
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "resetAllowance",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/GenericRebalancer.d.ts b/generated/abis/GenericRebalancer.d.ts
index 2649a77..02676fa 100644
--- a/generated/abis/GenericRebalancer.d.ts
+++ b/generated/abis/GenericRebalancer.d.ts
@@ -88,11 +88,6 @@ export type Abi_GenericRebalancer = [
     "name": "NotTrustedOrGuardian",
     "type": "error"
   },
-  {
-    "inputs": [],
-    "name": "RouterDidNotConsumeAllTokens",
-    "type": "error"
-  },
   {
     "inputs": [
       {
@@ -119,6 +114,25 @@ export type Abi_GenericRebalancer = [
     "name": "ZeroAmount",
     "type": "error"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "AllowanceReset",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -450,6 +464,24 @@ export type Abi_GenericRebalancer = [
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "resetAllowance",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/GenericRebalancer.js b/generated/abis/GenericRebalancer.js
index 626c4fb..816a64c 100644
--- a/generated/abis/GenericRebalancer.js
+++ b/generated/abis/GenericRebalancer.js
@@ -88,11 +88,6 @@ export const Abi_GenericRebalancer = /** @type {const} **/ ([
     "name": "NotTrustedOrGuardian",
     "type": "error"
   },
-  {
-    "inputs": [],
-    "name": "RouterDidNotConsumeAllTokens",
-    "type": "error"
-  },
   {
     "inputs": [
       {
@@ -119,6 +114,25 @@ export const Abi_GenericRebalancer = /** @type {const} **/ ([
     "name": "ZeroAmount",
     "type": "error"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "AllowanceReset",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -450,6 +464,24 @@ export const Abi_GenericRebalancer = /** @type {const} **/ ([
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "resetAllowance",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/MultiBlockRebalancer.d.ts b/generated/abis/MultiBlockRebalancer.d.ts
index 96cff3f..18e1fcb 100644
--- a/generated/abis/MultiBlockRebalancer.d.ts
+++ b/generated/abis/MultiBlockRebalancer.d.ts
@@ -94,6 +94,25 @@ export type Abi_MultiBlockRebalancer = [
     "name": "ZeroAmount",
     "type": "error"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "AllowanceReset",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -297,6 +316,24 @@ export type Abi_MultiBlockRebalancer = [
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "resetAllowance",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/MultiBlockRebalancer.js b/generated/abis/MultiBlockRebalancer.js
index c2abb49..523e7b2 100644
--- a/generated/abis/MultiBlockRebalancer.js
+++ b/generated/abis/MultiBlockRebalancer.js
@@ -94,6 +94,25 @@ export const Abi_MultiBlockRebalancer = /** @type {const} **/ ([
     "name": "ZeroAmount",
     "type": "error"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "AllowanceReset",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -297,6 +316,24 @@ export const Abi_MultiBlockRebalancer = /** @type {const} **/ ([
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "spender",
+        "type": "address"
+      }
+    ],
+    "name": "resetAllowance",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/scripts/SetGenericRebalancerRoles.s.sol b/scripts/SetGenericRebalancerRoles.s.sol
index 6f81662..086c6ef 100644
--- a/scripts/SetGenericRebalancerRoles.s.sol
+++ b/scripts/SetGenericRebalancerRoles.s.sol
@@ -10,12 +10,13 @@ contract SetGenericRebalancerRoles is BaseScript {
   address genericRebalancer = 0x57770C1721Eb35509f38210A935c8b1911db7E0e;
 
   function run() public broadcast {
-    bytes4[] memory guardianSelectors = new bytes4[](5);
+    bytes4[] memory guardianSelectors = new bytes4[](6);
     guardianSelectors[0] = BaseRebalancer.setYieldBearingAssetData.selector;
     guardianSelectors[1] = BaseRebalancer.setMaxSlippage.selector;
     guardianSelectors[2] = BaseRebalancer.toggleTrusted.selector;
     guardianSelectors[3] = BaseRebalancer.recoverERC20.selector;
     guardianSelectors[4] = BaseRebalancer.setTargetExposure.selector;
+    guardianSelectors[5] = BaseRebalancer.resetAllowance.selector;
     accessManager.setTargetFunctionRole(genericRebalancer, guardianSelectors, Roles.GUARDIAN_ROLE);
 
     bytes4[] memory governorSelectors = new bytes4[](2);
diff --git a/tests/units/Rebalancer.t.sol b/tests/units/Rebalancer.t.sol
index 00f0244..d0376ea 100644
--- a/tests/units/Rebalancer.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -127,3 +127,78 @@ contract Test_Rebalancer_ResidualInput is Fixture {
     assertGt(rebalancer.budget(alice), budgetBefore, "settlement surplus not credited");
   }
 }
+
+
+contract Test_Rebalancer_Allowances is Fixture {
+  MultiBlockRebalancer internal rebalancer;
+
+  function setUp() public override {
+    super.setUp();
+
+    rebalancer = new MultiBlockRebalancer(address(accessManager), tokenP, parallelizer);
+
+    vm.startPrank(governor);
+    accessManager.setTargetFunctionRole(
+      address(rebalancer), getGuardianBaseRebalancerSelectorAccess(), GUARDIAN_ROLE
+    );
+    accessManager.setTargetFunctionRole(
+      address(rebalancer), getGovernorMultiBlockRebalancerSelectorAccess(), GOVERNOR_ROLE
+    );
+    accessManager.grantRole(GUARDIAN_ROLE, guardian, 0);
+    vm.stopPrank();
+
+    vm.prank(guardian);
+    rebalancer.setYieldBearingAssetData(address(eurY), address(eurA), 5e8, 1e8, 9e8, 1, 5e7);
+  }
+
+  /// @dev Stands in for the unlimited allowance a previous rebalance would have granted
+  function _seedAllowance(address token, address spender) internal {
+    vm.prank(address(rebalancer));
+    IERC20(token).approve(spender, type(uint256).max);
+    assertEq(IERC20(token).allowance(address(rebalancer), spender), type(uint256).max);
+  }
+
+  function test_RotatingTheAsset_RevokesTheOutgoingAllowance() public {
+    _seedAllowance(address(eurA), address(eurY));
+
+    vm.prank(guardian);
+    rebalancer.setYieldBearingAssetData(address(eurY), address(eurB), 5e8, 1e8, 9e8, 1, 5e7);
+
+    assertEq(IERC20(address(eurA)).allowance(address(rebalancer), address(eurY)), 0);
+  }
+
+  function test_RotatingTheAsset_KeepsTheAllowanceWhenAssetIsUnchanged() public {
+    _seedAllowance(address(eurA), address(eurY));
+
+    vm.prank(guardian);
+    rebalancer.setYieldBearingAssetData(address(eurY), address(eurA), 4e8, 1e8, 9e8, 1, 5e7);
+
+    assertEq(IERC20(address(eurA)).allowance(address(rebalancer), address(eurY)), type(uint256).max);
+  }
+
+  function test_RotatingTheDepositAddress_RevokesTheOutgoingAllowance() public {
+    vm.prank(governor);
+    rebalancer.setYieldBearingToDepositAddress(address(eurY), bob);
+    _seedAllowance(address(eurA), bob);
+
+    vm.prank(governor);
+    rebalancer.setYieldBearingToDepositAddress(address(eurY), charlie);
+
+    assertEq(IERC20(address(eurA)).allowance(address(rebalancer), bob), 0);
+  }
+
+  function test_ResetAllowance() public {
+    _seedAllowance(address(eurA), bob);
+
+    vm.prank(guardian);
+    rebalancer.resetAllowance(address(eurA), bob);
+
+    assertEq(IERC20(address(eurA)).allowance(address(rebalancer), bob), 0);
+  }
+
+  function test_RevertWhen_ResetAllowanceNotGuardian() public {
+    vm.prank(alice);
+    vm.expectRevert(abi.encodeWithSelector(Errors.AccessManagedUnauthorized.selector, alice));
+    rebalancer.resetAllowance(address(eurA), bob);
+  }
+}
diff --git a/tests/utils/ConfigAccessManager.sol b/tests/utils/ConfigAccessManager.sol
index c603576..3fa285e 100644
--- a/tests/utils/ConfigAccessManager.sol
+++ b/tests/utils/ConfigAccessManager.sol
@@ -63,12 +63,13 @@ abstract contract ConfigAccessManager is Helper {
   }
 
   function getGuardianBaseRebalancerSelectorAccess() internal pure returns (bytes4[] memory) {
-    bytes4[] memory selectors = new bytes4[](5);
+    bytes4[] memory selectors = new bytes4[](6);
     selectors[0] = BaseRebalancer.setYieldBearingAssetData.selector;
     selectors[1] = BaseRebalancer.setMaxSlippage.selector;
     selectors[2] = BaseRebalancer.toggleTrusted.selector;
     selectors[3] = BaseRebalancer.recoverERC20.selector;
     selectors[4] = BaseRebalancer.setTargetExposure.selector;
+    selectors[5] = BaseRebalancer.resetAllowance.selector;
     return selectors;
   }
 

From 9a12fc6c1ea83df2a24885a3692f4f83b008719e Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 12:16:21 +0300
Subject: [PATCH 12/38] fix(rebalancer): settle the flash loan fee instead of
 rejecting it

`onFlashLoan` refused any callback reporting a non-zero fee, so enabling the
USDp flash loan fee would have left the rebalancer with no working path to
adjust the Parallelizer's yield bearing exposure.

The fee is now folded into what the lender pulls back and settled against the
budget of the address that called `harvest`, alongside the usual shortfall or
surplus. A fee the caller cannot cover fails the rebalance rather than reaching
into another caller's budget.

Bailsec Core Issue_06
---
 contracts/helpers/GenericRebalancer.sol |  6 +-
 tests/mock/MockFlashLoan.sol            | 17 +++--
 tests/units/Rebalancer.t.sol            | 97 +++++++++++++++++++++++++
 3 files changed, 114 insertions(+), 6 deletions(-)

diff --git a/contracts/helpers/GenericRebalancer.sol b/contracts/helpers/GenericRebalancer.sol
index fa40258..5984850 100644
--- a/contracts/helpers/GenericRebalancer.sol
+++ b/contracts/helpers/GenericRebalancer.sol
@@ -121,6 +121,8 @@ contract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapp
   }
 
   /// @inheritdoc IERC3156FlashBorrower
+  /// @dev A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any
+  /// shortfall between the principal and the tokenP the rebalance minted back
   function onFlashLoan(
     address initiator,
     address,
@@ -132,7 +134,7 @@ contract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapp
     virtual
     returns (bytes32)
   {
-    if (msg.sender != address(flashloan) || initiator != address(this) || fee != 0) revert NotTrusted();
+    if (msg.sender != address(flashloan) || initiator != address(this)) revert NotTrusted();
     address sender;
     uint256 typeAction;
     uint256 minAmountOut;
@@ -159,6 +161,8 @@ contract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapp
 
     uint256 amountOut =
       parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);
+    // The principal is spent, what the lender will pull back is the principal plus its fee
+    amount += fee;
 
     // Swap to tokenOut
     amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);
diff --git a/tests/mock/MockFlashLoan.sol b/tests/mock/MockFlashLoan.sol
index b2ac3f0..94d818e 100644
--- a/tests/mock/MockFlashLoan.sol
+++ b/tests/mock/MockFlashLoan.sol
@@ -6,17 +6,23 @@ import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
 import { MockTokenPermit } from "./MockTokenPermit.sol";
 
-/// @dev Zero-fee ERC-3156 lender: mints the principal to the borrower and pulls it back through the
+/// @dev ERC-3156 lender: mints the principal to the borrower and pulls back principal plus fee through the
 /// allowance the borrower granted, mirroring FlashParallelToken closely enough for the rebalancer.
 contract MockFlashLoan {
   bytes32 internal constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
 
+  uint256 public feeRate;
+
+  function setFeeRate(uint256 newFeeRate) external {
+    feeRate = newFeeRate;
+  }
+
   function maxFlashLoan(address) external pure returns (uint256) {
     return type(uint256).max;
   }
 
-  function flashFee(address, uint256) external pure returns (uint256) {
-    return 0;
+  function flashFee(address, uint256 amount) public view returns (uint256) {
+    return (amount * feeRate) / 1e9;
   }
 
   function flashLoan(
@@ -28,9 +34,10 @@ contract MockFlashLoan {
     external
     returns (bool)
   {
+    uint256 fee = flashFee(token, amount);
     MockTokenPermit(token).mint(address(receiver), amount);
-    require(receiver.onFlashLoan(msg.sender, token, amount, 0, data) == CALLBACK_SUCCESS, "bad callback");
-    IERC20(token).transferFrom(address(receiver), address(this), amount);
+    require(receiver.onFlashLoan(msg.sender, token, amount, fee, data) == CALLBACK_SUCCESS, "bad callback");
+    IERC20(token).transferFrom(address(receiver), address(this), amount + fee);
     MockTokenPermit(token).burn(address(this), amount);
     return true;
   }
diff --git a/tests/units/Rebalancer.t.sol b/tests/units/Rebalancer.t.sol
index d0376ea..b981c14 100644
--- a/tests/units/Rebalancer.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -4,6 +4,7 @@ pragma solidity 0.8.28;
 
 import { MultiBlockRebalancer } from "contracts/helpers/MultiBlockRebalancer.sol";
 import { GenericRebalancer, SwapType } from "contracts/helpers/GenericRebalancer.sol";
+import { stdError } from "@forge-std/Test.sol";
 import { IERC3156FlashLender } from "@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol";
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 
@@ -202,3 +203,99 @@ contract Test_Rebalancer_Allowances is Fixture {
     rebalancer.resetAllowance(address(eurA), bob);
   }
 }
+
+
+contract Test_Rebalancer_FlashLoanFee is Fixture {
+  GenericRebalancer internal rebalancer;
+  MockRouter internal router;
+  MockFlashLoan internal lender;
+
+  function setUp() public override {
+    super.setUp();
+
+    router = new MockRouter();
+    lender = new MockFlashLoan();
+    rebalancer = new GenericRebalancer(
+      address(router), address(router), tokenP, parallelizer, address(accessManager), IERC3156FlashLender(address(lender))
+    );
+
+    vm.startPrank(governor);
+    accessManager.setTargetFunctionRole(
+      address(rebalancer), getGuardianBaseRebalancerSelectorAccess(), GUARDIAN_ROLE
+    );
+    accessManager.grantRole(GUARDIAN_ROLE, guardian, 0);
+    vm.stopPrank();
+
+    vm.startPrank(guardian);
+    rebalancer.toggleTrusted(alice);
+    rebalancer.setYieldBearingAssetData(address(eurY), address(eurA), 2e8, 1e7, 9e8, 1, 5e8);
+    vm.stopPrank();
+
+    _mintCollateral(address(eurY), 100_000 ether);
+    _mintCollateral(address(eurA), 1000 * BASE_6);
+
+    deal(address(eurA), address(router), 1_000_000 * BASE_6);
+    deal(address(tokenP), alice, 100_000 ether);
+    vm.startPrank(alice);
+    IERC20(address(tokenP)).approve(address(rebalancer), type(uint256).max);
+    rebalancer.addBudget(50_000 ether, alice);
+    vm.stopPrank();
+  }
+
+  function _mintCollateral(address collateral, uint256 amount) internal {
+    deal(collateral, governor, amount);
+    vm.startPrank(governor);
+    IERC20(collateral).approve(address(parallelizer), amount);
+    parallelizer.swapExactInput(amount, 0, collateral, address(tokenP), governor, block.timestamp + 1 hours);
+    vm.stopPrank();
+  }
+
+  function _harvest() internal {
+    bytes memory swapData =
+      abi.encodeWithSelector(MockRouter.swap.selector, 1 ether, address(eurY), 5000 * BASE_6, address(eurA));
+    vm.prank(alice);
+    rebalancer.harvest(address(eurY), 1e7, abi.encode(SwapType.SWAP, swapData));
+  }
+
+  /// @dev A lender charging a fee must not lock the rebalancer out of its only rebalance path
+  function test_Harvest_SucceedsWithANonZeroFee() public {
+    lender.setFeeRate(5e5);
+
+    _harvest();
+
+    assertGt(lender.flashFee(address(tokenP), 1 ether), 0, "fee rate produced no fee");
+  }
+
+  /// @dev The fee is settled out of the budget of the address that asked for the rebalance
+  function test_Harvest_ChargesTheFeeToTheCallerBudget() public {
+    uint256 snapshot = vm.snapshotState();
+
+    _harvest();
+    uint256 budgetWithoutFee = rebalancer.budget(alice);
+
+    vm.revertToState(snapshot);
+
+    lender.setFeeRate(5e5);
+    _harvest();
+    uint256 budgetWithFee = rebalancer.budget(alice);
+
+    assertLt(budgetWithFee, budgetWithoutFee, "fee was not charged");
+    // The lender kept exactly what it was owed on top of the principal
+    assertEq(
+      budgetWithoutFee - budgetWithFee,
+      IERC20(address(tokenP)).balanceOf(address(lender)),
+      "budget delta does not match the fee the lender collected"
+    );
+  }
+
+  /// @dev A fee the caller cannot cover fails the rebalance rather than dipping into other budgets
+  function test_RevertWhen_FeeExceedsTheCallerBudget() public {
+    lender.setFeeRate(1e15);
+
+    bytes memory swapData =
+      abi.encodeWithSelector(MockRouter.swap.selector, 1 ether, address(eurY), 5000 * BASE_6, address(eurA));
+    vm.prank(alice);
+    vm.expectRevert(stdError.arithmeticError);
+    rebalancer.harvest(address(eurY), 1e7, abi.encode(SwapType.SWAP, swapData));
+  }
+}

From 07c159f236eac7e6ca5182c7f95abe53f8e94245 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 12:55:34 +0300
Subject: [PATCH 13/38] test(rebalancer): express the mock flash loan fee in
 basis points

FlashParallelToken stores `feesRate` as a uint16 in basis points, capped at
100%. The mock scaled by 1e9 instead, so its rates read five orders of
magnitude away from anything governance could actually set.

The budget shortfall case now uses that real ceiling against a route that
clears `minAmountOut` with nothing spare, rather than a fee rate the live
contract would reject.
---
 tests/mock/MockFlashLoan.sol | 10 ++++++----
 tests/units/Rebalancer.t.sol | 13 +++++++++----
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/tests/mock/MockFlashLoan.sol b/tests/mock/MockFlashLoan.sol
index 94d818e..139ada6 100644
--- a/tests/mock/MockFlashLoan.sol
+++ b/tests/mock/MockFlashLoan.sol
@@ -11,10 +11,12 @@ import { MockTokenPermit } from "./MockTokenPermit.sol";
 contract MockFlashLoan {
   bytes32 internal constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
 
-  uint256 public feeRate;
+  /// @dev Basis points, as FlashParallelToken stores it
+  uint16 public feeRateBps;
 
-  function setFeeRate(uint256 newFeeRate) external {
-    feeRate = newFeeRate;
+  function setFeeRateBps(uint16 newFeeRateBps) external {
+    require(newFeeRateBps <= 1e4, "fee rate above 100%");
+    feeRateBps = newFeeRateBps;
   }
 
   function maxFlashLoan(address) external pure returns (uint256) {
@@ -22,7 +24,7 @@ contract MockFlashLoan {
   }
 
   function flashFee(address, uint256 amount) public view returns (uint256) {
-    return (amount * feeRate) / 1e9;
+    return (amount * feeRateBps) / 1e4;
   }
 
   function flashLoan(
diff --git a/tests/units/Rebalancer.t.sol b/tests/units/Rebalancer.t.sol
index b981c14..0754144 100644
--- a/tests/units/Rebalancer.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -259,7 +259,7 @@ contract Test_Rebalancer_FlashLoanFee is Fixture {
 
   /// @dev A lender charging a fee must not lock the rebalancer out of its only rebalance path
   function test_Harvest_SucceedsWithANonZeroFee() public {
-    lender.setFeeRate(5e5);
+    lender.setFeeRateBps(5);
 
     _harvest();
 
@@ -275,7 +275,7 @@ contract Test_Rebalancer_FlashLoanFee is Fixture {
 
     vm.revertToState(snapshot);
 
-    lender.setFeeRate(5e5);
+    lender.setFeeRateBps(5);
     _harvest();
     uint256 budgetWithFee = rebalancer.budget(alice);
 
@@ -290,10 +290,15 @@ contract Test_Rebalancer_FlashLoanFee is Fixture {
 
   /// @dev A fee the caller cannot cover fails the rebalance rather than dipping into other budgets
   function test_RevertWhen_FeeExceedsTheCallerBudget() public {
-    lender.setFeeRate(1e15);
+    // The ceiling FlashParallelToken allows governance to set
+    lender.setFeeRateBps(1e4);
+    uint256 drained = rebalancer.budget(alice) - 1 ether;
+    vm.prank(alice);
+    rebalancer.removeBudget(drained, alice);
 
+    // A route that clears `minAmountOut` but leaves nothing spare to absorb the fee
     bytes memory swapData =
-      abi.encodeWithSelector(MockRouter.swap.selector, 1 ether, address(eurY), 5000 * BASE_6, address(eurA));
+      abi.encodeWithSelector(MockRouter.swap.selector, 1 ether, address(eurY), 500 * BASE_6, address(eurA));
     vm.prank(alice);
     vm.expectRevert(stdError.arithmeticError);
     rebalancer.harvest(address(eurY), 1e7, abi.encode(SwapType.SWAP, swapData));

From cbe2e3ea37cfaede78bfb1c9e05357320b253efe Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 15:47:19 +0300
Subject: [PATCH 14/38] fix(redeemer): bind the redemption output list to the
 caller's intent

`minAmountOuts` is positional and the output list is rebuilt at execution time
from the live `collateralList`. A revoke (swap and pop) followed by an add
preserves the length while reshuffling the tokens, so each minimum ends up
guarding a token the caller never quoted.

The three redeem entry points now take an `expectedTokensHash` over the output
list, checked against the live one, and the authorized path folds it into the
derived EIP-3009 nonce so a relayer cannot hold a signature until governance
rotates collateral.

This changes the ABI of `redeem`, `redeemWithForfeit` and
`redeemWithAuthorization`, and invalidates any redemption signature outstanding
at upgrade time.

Bailsec Core Issue_09
---
 contracts/interfaces/IRedeemer.sol            |  16 +-
 contracts/parallelizer/facets/Redeemer.sol    |  43 +--
 .../libraries/LibAuthorization.sol            |   8 +-
 contracts/utils/Errors.sol                    |   1 +
 generated/abis/IParallelizer.d.ts             |  15 +
 generated/abis/IParallelizer.js               |  15 +
 generated/abis/IRedeemer.d.ts                 |  15 +
 generated/abis/IRedeemer.js                   |  15 +
 generated/abis/Redeemer.d.ts                  |  20 ++
 generated/abis/Redeemer.js                    |  20 ++
 .../generated/DummyDiamondImplementation.sol  |   6 +-
 .../DummyDiamondImplementationSidechain.sol   |   6 +-
 tests/Fixture.sol                             |  29 +-
 tests/fuzz/Redeem.t.sol                       | 329 +++++++++++-------
 tests/invariants/actors/Arbitrager.t.sol      |  10 +-
 .../actors/ArbitragerWithSplit.t.sol          |  16 +-
 tests/invariants/actors/BaseActor.t.sol       |   7 +
 tests/mock/MockReentrant.sol                  |  18 +-
 tests/units/RedemptionTokenBinding.t.sol      | 111 ++++++
 tests/units/Setters.t.sol                     |   6 +-
 20 files changed, 526 insertions(+), 180 deletions(-)
 create mode 100644 tests/units/RedemptionTokenBinding.t.sol

diff --git a/contracts/interfaces/IRedeemer.sol b/contracts/interfaces/IRedeemer.sol
index 029b77c..912434c 100644
--- a/contracts/interfaces/IRedeemer.sol
+++ b/contracts/interfaces/IRedeemer.sol
@@ -11,13 +11,17 @@ interface IRedeemer {
   /// @param receiver Address which should be receiving the output tokens
   /// @param deadline Timestamp before which the redemption should have occured
   /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain
+  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was
+  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since
+  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects
   /// @return tokens List of tokens returned
   /// @return amounts Amount given for each token in the `tokens` array
   function redeem(
     uint256 amount,
     address receiver,
     uint256 deadline,
-    uint256[] memory minAmountOuts
+    uint256[] memory minAmountOuts,
+    bytes32 expectedTokensHash
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts);
@@ -29,7 +33,8 @@ interface IRedeemer {
     address receiver,
     uint256 deadline,
     uint256[] memory minAmountOuts,
-    address[] memory forfeitTokens
+    address[] memory forfeitTokens,
+    bytes32 expectedTokensHash
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts);
@@ -37,14 +42,17 @@ interface IRedeemer {
   /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP
   /// transfer.
   /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that
-  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the
-  /// signature. `authData.nonce` carries the caller-chosen `userSalt`.
+  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`
+  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.
+  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity
+  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list
   function redeemWithAuthorization(
     uint256 amount,
     address receiver,
     uint256 deadline,
     uint256[] memory minAmountOuts,
     address[] memory forfeitTokens,
+    bytes32 expectedTokensHash,
     bytes memory authData
   )
     external
diff --git a/contracts/parallelizer/facets/Redeemer.sol b/contracts/parallelizer/facets/Redeemer.sol
index 7539018..f1a3a3f 100644
--- a/contracts/parallelizer/facets/Redeemer.sol
+++ b/contracts/parallelizer/facets/Redeemer.sol
@@ -66,12 +66,13 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
     uint256 amount,
     address receiver,
     uint256 deadline,
-    uint256[] memory minAmountOuts
+    uint256[] memory minAmountOuts,
+    bytes32 expectedTokensHash
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts)
   {
-    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), "");
+    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), expectedTokensHash, "");
   }
 
   /// @inheritdoc IRedeemer
@@ -82,12 +83,13 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
     address receiver,
     uint256 deadline,
     uint256[] memory minAmountOuts,
-    address[] memory forfeitTokens
+    address[] memory forfeitTokens,
+    bytes32 expectedTokensHash
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts)
   {
-    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, "");
+    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, "");
   }
 
   /// @inheritdoc IRedeemer
@@ -97,12 +99,13 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
     uint256 deadline,
     uint256[] memory minAmountOuts,
     address[] memory forfeitTokens,
+    bytes32 expectedTokensHash,
     bytes memory authData
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts)
   {
-    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, authData);
+    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);
   }
 
   /// @inheritdoc IRedeemer
@@ -148,6 +151,7 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
     uint256 deadline,
     uint256[] memory minAmountOuts,
     address[] memory forfeitTokens,
+    bytes32 expectedTokensHash,
     bytes memory authData
   )
     internal
@@ -165,9 +169,13 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
 
     (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);
     if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();
+    // `minAmountOuts` is positional, so it only protects quantities. Binding the output list itself is what
+    // ties each minimum to the token it was quoted against, across a collateral rotation
+    if (keccak256(abi.encodePacked(redemption.tokens)) != expectedTokensHash) revert UnexpectedRedemptionTokens();
     _updateNormalizer(amount, false);
 
-    redemption.from = _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, authData);
+    redemption.from =
+      _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);
 
     _distributeRedemption(redemption);
     emit Redeemed(
@@ -197,9 +205,7 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
           revert NotWhitelisted();
         }
         if (collatInfo.isManaged > 0) {
-          LibManager.release(
-            redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config
-          );
+          LibManager.release(redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config);
         } else {
           IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);
         }
@@ -216,6 +222,7 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
     uint256 deadline,
     uint256[] memory minAmountOuts,
     address[] memory forfeitTokens,
+    bytes32 expectedTokensHash,
     bytes memory authData
   )
     internal
@@ -223,7 +230,7 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
   {
     ITokenP tokenP = s.transmuterStorage().tokenP;
     if (authData.length > 0) {
-      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, authData);
+      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);
       tokenP.burnSelf(amount, address(this));
     } else {
       from = msg.sender;
@@ -240,6 +247,7 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
     uint256 deadline,
     uint256[] memory minAmountOuts,
     address[] memory forfeitTokens,
+    bytes32 expectedTokensHash,
     bytes memory authData
   )
     internal
@@ -248,17 +256,12 @@ contract Redeemer is IRedeemer, AccessManagedModifiers {
     AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));
     if (params.value != amount) revert InvalidSwap();
     bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(
-      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, params.nonce
-    );
-    IEIP3009(address(s.transmuterStorage().tokenP)).receiveWithAuthorization(
-      params.from,
-      address(this),
-      params.value,
-      params.validAfter,
-      params.validBefore,
-      derivedNonce,
-      params.signature
+      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, params.nonce
     );
+    IEIP3009(address(s.transmuterStorage().tokenP))
+      .receiveWithAuthorization(
+        params.from, address(this), params.value, params.validAfter, params.validBefore, derivedNonce, params.signature
+      );
     return params.from;
   }
 
diff --git a/contracts/parallelizer/libraries/LibAuthorization.sol b/contracts/parallelizer/libraries/LibAuthorization.sol
index 8b9bbdf..ad70d37 100644
--- a/contracts/parallelizer/libraries/LibAuthorization.sol
+++ b/contracts/parallelizer/libraries/LibAuthorization.sol
@@ -25,9 +25,9 @@ library LibAuthorization {
     0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;
 
   // keccak256("RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32
-  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 userSalt)")
+  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 expectedTokensHash,bytes32 userSalt)")
   bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =
-    0xcff34e096e1842f6f6ae4c0d0c6eefd4855c8bdc5bc64155d7c14b2dbeee661a;
+    0xb6577f08e668b53303325a19233e8315142d69bedb6d7e1d8d0e9af2473486d4;
 
   function computeSwapExactInputNonce(
     address from,
@@ -87,6 +87,8 @@ library LibAuthorization {
     );
   }
 
+  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the redemption output list the
+  /// authorizer was quoted, binding token identity and ordering rather than raw amounts alone
   function computeRedeemNonce(
     address from,
     uint256 amount,
@@ -94,6 +96,7 @@ library LibAuthorization {
     uint256 deadline,
     uint256[] memory minAmountOuts,
     address[] memory forfeitTokens,
+    bytes32 expectedTokensHash,
     bytes32 userSalt
   )
     internal
@@ -109,6 +112,7 @@ library LibAuthorization {
         deadline,
         keccak256(abi.encodePacked(minAmountOuts)),
         keccak256(abi.encodePacked(forfeitTokens)),
+        expectedTokensHash,
         userSalt
       )
     );
diff --git a/contracts/utils/Errors.sol b/contracts/utils/Errors.sol
index 6ee3525..35b7d99 100644
--- a/contracts/utils/Errors.sol
+++ b/contracts/utils/Errors.sol
@@ -51,6 +51,7 @@ error RemoveFacetAddressMustBeZeroAddress(address _facetAddress);
 error TooBigAmountIn();
 error TooLate();
 error TooSmallAmountOut();
+error UnexpectedRedemptionTokens();
 error ZeroAddress();
 error ZeroAmount();
 error ZeroSurplusAmount();
diff --git a/generated/abis/IParallelizer.d.ts b/generated/abis/IParallelizer.d.ts
index 83c7203..40cf117 100644
--- a/generated/abis/IParallelizer.d.ts
+++ b/generated/abis/IParallelizer.d.ts
@@ -1064,6 +1064,11 @@ export type Abi_IParallelizer = [
         "internalType": "uint256[]",
         "name": "minAmountOuts",
         "type": "uint256[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeem",
@@ -1109,6 +1114,11 @@ export type Abi_IParallelizer = [
         "name": "forfeitTokens",
         "type": "address[]"
       },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
+      },
       {
         "internalType": "bytes",
         "name": "authData",
@@ -1157,6 +1167,11 @@ export type Abi_IParallelizer = [
         "internalType": "address[]",
         "name": "forfeitTokens",
         "type": "address[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeemWithForfeit",
diff --git a/generated/abis/IParallelizer.js b/generated/abis/IParallelizer.js
index 167cd07..c95621f 100644
--- a/generated/abis/IParallelizer.js
+++ b/generated/abis/IParallelizer.js
@@ -1064,6 +1064,11 @@ export const Abi_IParallelizer = /** @type {const} **/ ([
         "internalType": "uint256[]",
         "name": "minAmountOuts",
         "type": "uint256[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeem",
@@ -1109,6 +1114,11 @@ export const Abi_IParallelizer = /** @type {const} **/ ([
         "name": "forfeitTokens",
         "type": "address[]"
       },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
+      },
       {
         "internalType": "bytes",
         "name": "authData",
@@ -1157,6 +1167,11 @@ export const Abi_IParallelizer = /** @type {const} **/ ([
         "internalType": "address[]",
         "name": "forfeitTokens",
         "type": "address[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeemWithForfeit",
diff --git a/generated/abis/IRedeemer.d.ts b/generated/abis/IRedeemer.d.ts
index 2880336..cbbde1c 100644
--- a/generated/abis/IRedeemer.d.ts
+++ b/generated/abis/IRedeemer.d.ts
@@ -44,6 +44,11 @@ export type Abi_IRedeemer = [
         "internalType": "uint256[]",
         "name": "minAmountOuts",
         "type": "uint256[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeem",
@@ -89,6 +94,11 @@ export type Abi_IRedeemer = [
         "name": "forfeitTokens",
         "type": "address[]"
       },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
+      },
       {
         "internalType": "bytes",
         "name": "authData",
@@ -137,6 +147,11 @@ export type Abi_IRedeemer = [
         "internalType": "address[]",
         "name": "forfeitTokens",
         "type": "address[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeemWithForfeit",
diff --git a/generated/abis/IRedeemer.js b/generated/abis/IRedeemer.js
index fed69ca..ea35c21 100644
--- a/generated/abis/IRedeemer.js
+++ b/generated/abis/IRedeemer.js
@@ -44,6 +44,11 @@ export const Abi_IRedeemer = /** @type {const} **/ ([
         "internalType": "uint256[]",
         "name": "minAmountOuts",
         "type": "uint256[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeem",
@@ -89,6 +94,11 @@ export const Abi_IRedeemer = /** @type {const} **/ ([
         "name": "forfeitTokens",
         "type": "address[]"
       },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
+      },
       {
         "internalType": "bytes",
         "name": "authData",
@@ -137,6 +147,11 @@ export const Abi_IRedeemer = /** @type {const} **/ ([
         "internalType": "address[]",
         "name": "forfeitTokens",
         "type": "address[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeemWithForfeit",
diff --git a/generated/abis/Redeemer.d.ts b/generated/abis/Redeemer.d.ts
index d421a03..d818654 100644
--- a/generated/abis/Redeemer.d.ts
+++ b/generated/abis/Redeemer.d.ts
@@ -76,6 +76,11 @@ export type Abi_Redeemer = [
     "name": "TooSmallAmountOut",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "UnexpectedRedemptionTokens",
+    "type": "error"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -177,6 +182,11 @@ export type Abi_Redeemer = [
         "internalType": "uint256[]",
         "name": "minAmountOuts",
         "type": "uint256[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeem",
@@ -222,6 +232,11 @@ export type Abi_Redeemer = [
         "name": "forfeitTokens",
         "type": "address[]"
       },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
+      },
       {
         "internalType": "bytes",
         "name": "authData",
@@ -270,6 +285,11 @@ export type Abi_Redeemer = [
         "internalType": "address[]",
         "name": "forfeitTokens",
         "type": "address[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeemWithForfeit",
diff --git a/generated/abis/Redeemer.js b/generated/abis/Redeemer.js
index cc04aa6..13ddb7e 100644
--- a/generated/abis/Redeemer.js
+++ b/generated/abis/Redeemer.js
@@ -76,6 +76,11 @@ export const Abi_Redeemer = /** @type {const} **/ ([
     "name": "TooSmallAmountOut",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "UnexpectedRedemptionTokens",
+    "type": "error"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -177,6 +182,11 @@ export const Abi_Redeemer = /** @type {const} **/ ([
         "internalType": "uint256[]",
         "name": "minAmountOuts",
         "type": "uint256[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeem",
@@ -222,6 +232,11 @@ export const Abi_Redeemer = /** @type {const} **/ ([
         "name": "forfeitTokens",
         "type": "address[]"
       },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
+      },
       {
         "internalType": "bytes",
         "name": "authData",
@@ -270,6 +285,11 @@ export const Abi_Redeemer = /** @type {const} **/ ([
         "internalType": "address[]",
         "name": "forfeitTokens",
         "type": "address[]"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "expectedTokensHash",
+        "type": "bytes32"
       }
     ],
     "name": "redeemWithForfeit",
diff --git a/scripts/generated/DummyDiamondImplementation.sol b/scripts/generated/DummyDiamondImplementation.sol
index c439866..dc142cb 100644
--- a/scripts/generated/DummyDiamondImplementation.sol
+++ b/scripts/generated/DummyDiamondImplementation.sol
@@ -229,7 +229,8 @@ contract DummyDiamondImplementation {
     uint256 amount,
     address receiver,
     uint256 deadline,
-    uint256[] memory minAmountOuts
+    uint256[] memory minAmountOuts,
+    bytes32 expectedTokensHash
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts)
@@ -240,7 +241,8 @@ contract DummyDiamondImplementation {
     address receiver,
     uint256 deadline,
     uint256[] memory minAmountOuts,
-    address[] memory forfeitTokens
+    address[] memory forfeitTokens,
+    bytes32 expectedTokensHash
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts)
diff --git a/scripts/generated/DummyDiamondImplementationSidechain.sol b/scripts/generated/DummyDiamondImplementationSidechain.sol
index 6bcb412..6019c8c 100644
--- a/scripts/generated/DummyDiamondImplementationSidechain.sol
+++ b/scripts/generated/DummyDiamondImplementationSidechain.sol
@@ -234,7 +234,8 @@ contract DummyDiamondImplementation {
     uint256 amount,
     address receiver,
     uint256 deadline,
-    uint256[] memory minAmountOuts
+    uint256[] memory minAmountOuts,
+    bytes32 expectedTokensHash
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts)
@@ -245,7 +246,8 @@ contract DummyDiamondImplementation {
     address receiver,
     uint256 deadline,
     uint256[] memory minAmountOuts,
-    address[] memory forfeitTokens
+    address[] memory forfeitTokens,
+    bytes32 expectedTokensHash
   )
     external
     returns (address[] memory tokens, uint256[] memory amounts)
diff --git a/tests/Fixture.sol b/tests/Fixture.sol
index 36b3032..0cd48e7 100644
--- a/tests/Fixture.sol
+++ b/tests/Fixture.sol
@@ -132,7 +132,7 @@ contract Fixture is Parallelizer, SavingsUtils, ConfigAccessManager {
   }
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    ASSERTIONS                                                    
+    ASSERTIONS
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
   // Allow to have larger deviation for very small amounts
@@ -155,7 +155,7 @@ contract Fixture is Parallelizer, SavingsUtils, ConfigAccessManager {
   }
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    ACTIONS                                                     
+    ACTIONS
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
   function _mintExactOutput(address owner, address tokenIn, uint256 amountStable, uint256 estimatedAmountIn) internal {
@@ -229,7 +229,7 @@ contract Fixture is Parallelizer, SavingsUtils, ConfigAccessManager {
 
   bytes32 internal constant PARALLELIZER_REDEEM_TYPEHASH = keccak256(
     "RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,"
-    "bytes32 minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 userSalt)"
+    "bytes32 minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 expectedTokensHash,bytes32 userSalt)"
   );
 
   function _buildSwapExactInputAuth(
@@ -249,15 +249,7 @@ contract Fixture is Parallelizer, SavingsUtils, ConfigAccessManager {
   {
     bytes32 derivedNonce = keccak256(
       abi.encode(
-        PARALLELIZER_SWAP_EXACT_INPUT_TYPEHASH,
-        from,
-        tokenIn,
-        tokenOut,
-        amountIn,
-        amountOutMin,
-        to,
-        deadline,
-        userSalt
+        PARALLELIZER_SWAP_EXACT_INPUT_TYPEHASH, from, tokenIn, tokenOut, amountIn, amountOutMin, to, deadline, userSalt
       )
     );
     return _signAndPackAuth(privateKey, tokenIn, from, amountIn, derivedNonce, userSalt);
@@ -302,6 +294,7 @@ contract Fixture is Parallelizer, SavingsUtils, ConfigAccessManager {
     uint256 deadline,
     uint256[] memory minAmountOuts,
     address[] memory forfeitTokens,
+    bytes32 expectedTokensHash,
     bytes32 userSalt
   )
     internal
@@ -317,12 +310,20 @@ contract Fixture is Parallelizer, SavingsUtils, ConfigAccessManager {
         deadline,
         keccak256(abi.encodePacked(minAmountOuts)),
         keccak256(abi.encodePacked(forfeitTokens)),
+        expectedTokensHash,
         userSalt
       )
     );
     return _signAndPackAuth(privateKey, address(tokenP), from, amount, derivedNonce, userSalt);
   }
 
+  /// @dev The output list a redemption of `amount` would produce right now, hashed as the redeem
+  /// entry points expect it
+  function _redemptionTokensHash(uint256 amount) internal view returns (bytes32) {
+    (address[] memory tokens,) = parallelizer.quoteRedemptionCurve(amount);
+    return keccak256(abi.encodePacked(tokens));
+  }
+
   /// @dev Signs an EIP-3009 `ReceiveWithAuthorization` with `nonce = signedNonce` and packs an
   /// `AuthorizationParams` whose on-the-wire `nonce` field carries `userSalt`, matching what the
   /// Parallelizer facets expect.
@@ -340,9 +341,7 @@ contract Fixture is Parallelizer, SavingsUtils, ConfigAccessManager {
   {
     uint256 validBefore = block.timestamp + 1 hours;
     bytes32 structHash = keccak256(
-      abi.encode(
-        RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, address(parallelizer), value, 0, validBefore, signedNonce
-      )
+      abi.encode(RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, address(parallelizer), value, 0, validBefore, signedNonce)
     );
     bytes32 digest = MessageHashUtils.toTypedDataHash(MockTokenPermit(token).DOMAIN_SEPARATOR(), structHash);
     (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, digest);
diff --git a/tests/fuzz/Redeem.t.sol b/tests/fuzz/Redeem.t.sol
index 60ca6c2..eccc559 100644
--- a/tests/fuzz/Redeem.t.sol
+++ b/tests/fuzz/Redeem.t.sol
@@ -34,6 +34,9 @@ struct AssertQuoteParams {
 }
 
 contract RedeemTest is Fixture, FunctionUtils {
+  /// @dev Kept in storage rather than a local: these fuzz tests already sit on the EVM stack limit
+  bytes32 internal tokensHash;
+
   using Math for uint256;
   using SafeERC20 for IERC20;
 
@@ -269,15 +272,19 @@ contract RedeemTest is Fixture, FunctionUtils {
     // --> redemption should be exactly in proportion of current balances
     vm.startPrank(alice);
     uint256 amountBurnt = tokenP.balanceOf(alice);
+    uint256[] memory quoteAmounts;
+    {
+      address[] memory quoteTokens;
+      if (mintedStables == 0) vm.expectRevert(stdError.divisionError);
+      else if (mintedStables == amountBurnt) vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
+      (quoteTokens, quoteAmounts) = parallelizer.quoteRedemptionCurve(amountBurnt);
+      tokensHash = keccak256(abi.encodePacked(quoteTokens));
+    }
     if (mintedStables == 0) vm.expectRevert(stdError.divisionError);
     else if (mintedStables == amountBurnt) vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    (, uint256[] memory quoteAmounts) = parallelizer.quoteRedemptionCurve(amountBurnt);
-    if (mintedStables == 0) vm.expectRevert(stdError.divisionError);
-    else if (mintedStables == amountBurnt) vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    // uint256[] memory forfeitTokens = new uint256[](0);
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     (address[] memory tokens, uint256[] memory amounts) =
-      parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+      parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, tokensHash);
     vm.stopPrank();
 
     if (mintedStables == 0 || mintedStables == amountBurnt) return;
@@ -328,7 +335,12 @@ contract RedeemTest is Fixture, FunctionUtils {
     uint256 amountBurnt = tokenP.balanceOf(alice);
     if (mintedStables == 0) vm.expectRevert(stdError.divisionError);
     else if (mintedStables == amountBurnt) vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    (, uint256[] memory quoteAmounts) = parallelizer.quoteRedemptionCurve(amountBurnt);
+    uint256[] memory quoteAmounts;
+    {
+      address[] memory quoteTokens;
+      (quoteTokens, quoteAmounts) = parallelizer.quoteRedemptionCurve(amountBurnt);
+      tokensHash = keccak256(abi.encodePacked(quoteTokens));
+    }
     if (mintedStables == 0) vm.expectRevert(stdError.divisionError);
     else if (mintedStables == amountBurnt) vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
     address[] memory tokens;
@@ -336,7 +348,7 @@ contract RedeemTest is Fixture, FunctionUtils {
     {
       // uint256[] memory forfeitTokens = new uint256[](0);
       uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
-      (tokens, amounts) = parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+      (tokens, amounts) = parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, tokensHash);
     }
     vm.stopPrank();
 
@@ -398,7 +410,9 @@ contract RedeemTest is Fixture, FunctionUtils {
       uint256[] memory amounts;
       {
         uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
-        (tokens, amounts) = parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+        (tokens, amounts) = parallelizer.redeem(
+          amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, _redemptionTokensHash(amountBurnt)
+        );
       }
       vm.stopPrank();
 
@@ -440,7 +454,9 @@ contract RedeemTest is Fixture, FunctionUtils {
 
       {
         uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
-        (tokens, amounts) = parallelizer.redeem(amountBurntBob, bob, block.timestamp + 1 days, minAmountOuts);
+        (tokens, amounts) = parallelizer.redeem(
+          amountBurntBob, bob, block.timestamp + 1 days, minAmountOuts, _redemptionTokensHash(amountBurntBob)
+        );
       }
       vm.stopPrank();
 
@@ -494,7 +510,7 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, bytes32(0));
   }
 
   function testFuzz_RevertWhen_BurningAllStableIssuedWithWhitelist(
@@ -513,10 +529,12 @@ contract RedeemTest is Fixture, FunctionUtils {
     }
 
     // Enable whitelist on the first collateral and whitelist alice
-    bytes memory emptyData;
-    bytes memory whitelistData = abi.encode(WhitelistType.BACKED, emptyData);
-    hoax(governor);
-    parallelizer.setWhitelistStatus(address(eurA), 1, whitelistData);
+    {
+      bytes memory emptyData;
+      bytes memory whitelistData = abi.encode(WhitelistType.BACKED, emptyData);
+      hoax(governor);
+      parallelizer.setWhitelistStatus(address(eurA), 1, whitelistData);
+    }
     hoax(guardian);
     parallelizer.toggleWhitelist(WhitelistType.BACKED, alice);
 
@@ -527,7 +545,7 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, bytes32(0));
   }
 
   function testFuzz_RedeemWithForfeit_RevertWhen_BurningAllStableIssued(
@@ -564,7 +582,9 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    parallelizer.redeemWithForfeit(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens);
+    parallelizer.redeemWithForfeit(
+      amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens, bytes32(0)
+    );
   }
 
   function testFuzz_RedeemWithForfeit_RevertWhen_BurningAllStableIssuedWithWhitelist(
@@ -595,10 +615,12 @@ contract RedeemTest is Fixture, FunctionUtils {
     }
 
     // Enable whitelist on the first collateral and whitelist alice
-    bytes memory emptyData;
-    bytes memory whitelistData = abi.encode(WhitelistType.BACKED, emptyData);
-    hoax(governor);
-    parallelizer.setWhitelistStatus(address(eurA), 1, whitelistData);
+    {
+      bytes memory emptyData;
+      bytes memory whitelistData = abi.encode(WhitelistType.BACKED, emptyData);
+      hoax(governor);
+      parallelizer.setWhitelistStatus(address(eurA), 1, whitelistData);
+    }
     hoax(guardian);
     parallelizer.toggleWhitelist(WhitelistType.BACKED, alice);
 
@@ -609,7 +631,9 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    parallelizer.redeemWithForfeit(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens);
+    parallelizer.redeemWithForfeit(
+      amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens, bytes32(0)
+    );
   }
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -745,7 +769,9 @@ contract RedeemTest is Fixture, FunctionUtils {
       address[] memory tokens;
       {
         uint256[] memory minAmountOuts = new uint256[](quoteAmounts.length);
-        (tokens, amounts) = parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+        (tokens, amounts) = parallelizer.redeem(
+          amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, _redemptionTokensHash(amountBurnt)
+        );
       }
       vm.stopPrank();
 
@@ -780,7 +806,9 @@ contract RedeemTest is Fixture, FunctionUtils {
       if (mintedStables == 0 || amountBurntBob >= mintedStables) return;
       {
         uint256[] memory minAmountOuts = new uint256[](quoteAmounts.length);
-        (tokens, amounts) = parallelizer.redeem(amountBurntBob, bob, block.timestamp + 1 days, minAmountOuts);
+        (tokens, amounts) = parallelizer.redeem(
+          amountBurntBob, bob, block.timestamp + 1 days, minAmountOuts, _redemptionTokensHash(amountBurntBob)
+        );
       }
       vm.stopPrank();
 
@@ -871,7 +899,7 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, bytes32(0));
   }
 
   function testFuzz_RevertWhen_BurningAllStableIssuedWithManagerAndWhitelist(
@@ -920,10 +948,12 @@ contract RedeemTest is Fixture, FunctionUtils {
     _randomRedeemptionFees(xFeeRedeemUnbounded, yFeeRedeemUnbounded);
 
     // Enable whitelist on the first collateral and whitelist alice
-    bytes memory emptyData;
-    bytes memory whitelistData = abi.encode(WhitelistType.BACKED, emptyData);
-    hoax(governor);
-    parallelizer.setWhitelistStatus(address(eurA), 1, whitelistData);
+    {
+      bytes memory emptyData;
+      bytes memory whitelistData = abi.encode(WhitelistType.BACKED, emptyData);
+      hoax(governor);
+      parallelizer.setWhitelistStatus(address(eurA), 1, whitelistData);
+    }
     hoax(guardian);
     parallelizer.toggleWhitelist(WhitelistType.BACKED, alice);
 
@@ -934,7 +964,7 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, bytes32(0));
   }
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -955,6 +985,7 @@ contract RedeemTest is Fixture, FunctionUtils {
     vm.startPrank(alice);
     uint256 amountBurnt = tokenP.balanceOf(alice);
     if (amountBurnt == mintedStables) return;
+    tokensHash = _redemptionTokensHash(amountBurnt);
     {
       uint256[] memory minAmountOuts;
       {
@@ -962,7 +993,7 @@ contract RedeemTest is Fixture, FunctionUtils {
         minAmountOuts = new uint256[](quoteAmounts.length - 1);
       }
       vm.expectRevert(Errors.InvalidLengths.selector);
-      parallelizer.redeem(amountBurnt, alice, block.timestamp * 2, minAmountOuts);
+      parallelizer.redeem(amountBurnt, alice, block.timestamp * 2, minAmountOuts, tokensHash);
     }
     {
       uint256[] memory minAmountOuts;
@@ -971,7 +1002,7 @@ contract RedeemTest is Fixture, FunctionUtils {
         minAmountOuts = new uint256[](quoteAmounts.length + 1);
       }
       vm.expectRevert(Errors.InvalidLengths.selector);
-      parallelizer.redeem(amountBurnt, alice, block.timestamp * 2, minAmountOuts);
+      parallelizer.redeem(amountBurnt, alice, block.timestamp * 2, minAmountOuts, tokensHash);
     }
     vm.stopPrank();
   }
@@ -1031,8 +1062,14 @@ contract RedeemTest is Fixture, FunctionUtils {
       address[] memory forfeitTokens = _getForfeitTokens(areForfeit);
       {
         uint256[] memory minAmountOuts = new uint256[](quoteAmounts.length);
-        (tokens, amounts) =
-          parallelizer.redeemWithForfeit(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens);
+        (tokens, amounts) = parallelizer.redeemWithForfeit(
+          amountBurnt,
+          alice,
+          block.timestamp + 1 days,
+          minAmountOuts,
+          forfeitTokens,
+          _redemptionTokensHash(amountBurnt)
+        );
       }
       vm.stopPrank();
 
@@ -1066,7 +1103,9 @@ contract RedeemTest is Fixture, FunctionUtils {
       if (mintedStables == 0 || amountBurntBob >= mintedStables) return;
       {
         uint256[] memory minAmountOuts = new uint256[](quoteAmounts.length);
-        (tokens, amounts) = parallelizer.redeem(amountBurntBob, bob, block.timestamp + 1 days, minAmountOuts);
+        (tokens, amounts) = parallelizer.redeem(
+          amountBurntBob, bob, block.timestamp + 1 days, minAmountOuts, _redemptionTokensHash(amountBurntBob)
+        );
       }
       vm.stopPrank();
 
@@ -1149,7 +1188,9 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     vm.expectRevert(Errors.CannotBurnAllStableIssued.selector);
-    parallelizer.redeemWithForfeit(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens);
+    parallelizer.redeemWithForfeit(
+      amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens, bytes32(0)
+    );
   }
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1163,10 +1204,12 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     _sweepBalances(alice, _collaterals);
 
-    bytes memory emptyData;
-    bytes memory whitelistData = abi.encode(WhitelistType.BACKED, emptyData);
-    hoax(governor);
-    parallelizer.setWhitelistStatus(address(eurA), 1, whitelistData);
+    {
+      bytes memory emptyData;
+      bytes memory whitelistData = abi.encode(WhitelistType.BACKED, emptyData);
+      hoax(governor);
+      parallelizer.setWhitelistStatus(address(eurA), 1, whitelistData);
+    }
 
     vm.startPrank(alice);
     uint256 amountBurnt = tokenP.balanceOf(alice);
@@ -1174,10 +1217,11 @@ contract RedeemTest is Fixture, FunctionUtils {
     (, uint256[] memory quoteAmounts) = parallelizer.quoteRedemptionCurve(amountBurnt);
     // There should be a non zero amount of EURA to transfer
     if (quoteAmounts[0] == 0) return;
+    tokensHash = _redemptionTokensHash(amountBurnt);
     vm.expectRevert(Errors.NotWhitelisted.selector);
 
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
-    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+    parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, tokensHash);
     vm.stopPrank();
 
     hoax(guardian);
@@ -1185,10 +1229,10 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     vm.startPrank(alice);
     vm.expectRevert(Errors.NotWhitelisted.selector);
-    parallelizer.redeem(amountBurnt, bob, block.timestamp + 1 days, minAmountOuts);
+    parallelizer.redeem(amountBurnt, bob, block.timestamp + 1 days, minAmountOuts, tokensHash);
 
     (address[] memory tokens, uint256[] memory amounts) =
-      parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts);
+      parallelizer.redeem(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, tokensHash);
     vm.stopPrank();
 
     assertEq(amounts, quoteAmounts);
@@ -1228,30 +1272,38 @@ contract RedeemTest is Fixture, FunctionUtils {
     if (mintedStables == 0 || amountBurnt == 0 || amountBurnt == mintedStables) return;
     (, uint256[] memory quoteAmounts) = parallelizer.quoteRedemptionCurve(amountBurnt);
     if (quoteAmounts[0] == 0 || quoteAmounts[1] == 0) return;
+    tokensHash = _redemptionTokensHash(amountBurnt);
     uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
     {
       vm.startPrank(alice);
       address[] memory forfeitTokens = new address[](0);
       vm.expectRevert(Errors.NotWhitelisted.selector);
-      parallelizer.redeemWithForfeit(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens);
+      parallelizer.redeemWithForfeit(
+        amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens, tokensHash
+      );
 
       address[] memory forfeitTokens1 = new address[](1);
       forfeitTokens1[0] = address(eurA);
       vm.expectRevert(Errors.NotWhitelisted.selector);
-      parallelizer.redeemWithForfeit(amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens);
+      parallelizer.redeemWithForfeit(
+        amountBurnt, alice, block.timestamp + 1 days, minAmountOuts, forfeitTokens, tokensHash
+      );
       vm.stopPrank();
       hoax(guardian);
       parallelizer.toggleWhitelist(WhitelistType.BACKED, alice);
       vm.startPrank(alice);
       vm.expectRevert(Errors.NotWhitelisted.selector);
-      parallelizer.redeemWithForfeit(amountBurnt, bob, block.timestamp + 1 days, minAmountOuts, forfeitTokens);
+      parallelizer.redeemWithForfeit(
+        amountBurnt, bob, block.timestamp + 1 days, minAmountOuts, forfeitTokens, tokensHash
+      );
     }
 
     address[] memory forfeitTokens2 = new address[](2);
     forfeitTokens2[0] = address(eurA);
     forfeitTokens2[1] = address(eurB);
-    (address[] memory tokens, uint256[] memory amounts) =
-      parallelizer.redeemWithForfeit(amountBurnt, bob, block.timestamp + 1 days, minAmountOuts, forfeitTokens2);
+    (address[] memory tokens, uint256[] memory amounts) = parallelizer.redeemWithForfeit(
+      amountBurnt, bob, block.timestamp + 1 days, minAmountOuts, forfeitTokens2, tokensHash
+    );
     vm.stopPrank();
 
     assertEq(amounts, quoteAmounts);
@@ -1811,8 +1863,9 @@ contract RedeemTest is Fixture, FunctionUtils {
     uint256 stablecoinsIssued = parallelizer.getTotalIssued();
     if (stablecoinsIssued > 1) {
       uint256[] memory minOuts = new uint256[](3);
+      tokensHash = _redemptionTokensHash(stablecoinsIssued - 1);
       vm.expectRevert();
-      parallelizer.redeem(stablecoinsIssued - 1, attacker, block.timestamp * 2, minOuts);
+      parallelizer.redeem(stablecoinsIssued - 1, attacker, block.timestamp * 2, minOuts, tokensHash);
     }
     vm.stopPrank();
 
@@ -1825,7 +1878,9 @@ contract RedeemTest is Fixture, FunctionUtils {
     uint256 mintB,
     uint256 mintY,
     uint256 redeemRatio
-  ) public {
+  )
+    public
+  {
     mintA = bound(mintA, 1e6, 1_000_000e6);
     mintB = bound(mintB, 1e12, 1_000_000e12);
     mintY = bound(mintY, 1e18, 1_000_000e18);
@@ -1843,8 +1898,9 @@ contract RedeemTest is Fixture, FunctionUtils {
     if (redeemAmount >= stablecoinsIssued) redeemAmount = stablecoinsIssued - 1;
 
     uint256[] memory minOuts = new uint256[](3);
+    tokensHash = _redemptionTokensHash(redeemAmount);
     vm.startPrank(alice);
-    parallelizer.redeem(redeemAmount, alice, block.timestamp * 2, minOuts);
+    parallelizer.redeem(redeemAmount, alice, block.timestamp * 2, minOuts, tokensHash);
     vm.stopPrank();
 
     assertGt(
@@ -1890,24 +1946,27 @@ contract RedeemTest is Fixture, FunctionUtils {
     uint256 tokenPBal = tokenP.balanceOf(alice);
     uint256 redeemAmount = tokenPBal / 4;
 
-    vm.startPrank(guardian);
-    uint64[] memory xRedemption = new uint64[](1);
-    xRedemption[0] = uint64(0);
-    int64[] memory yRedemption = new int64[](1);
-    yRedemption[0] = int64(int256(BASE_9));
-    parallelizer.setRedemptionCurveParams(xRedemption, yRedemption);
-    vm.stopPrank();
+    {
+      vm.startPrank(guardian);
+      uint64[] memory xRedemption = new uint64[](1);
+      xRedemption[0] = uint64(0);
+      int64[] memory yRedemption = new int64[](1);
+      yRedemption[0] = int64(int256(BASE_9));
+      parallelizer.setRedemptionCurveParams(xRedemption, yRedemption);
+      vm.stopPrank();
+    }
 
     uint256 deadline = block.timestamp + 1 hours;
     uint256[] memory minOuts = new uint256[](3);
+    tokensHash = _redemptionTokensHash(redeemAmount);
     address[] memory forfeit = new address[](0);
     bytes memory authData =
-      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, bytes32("redeem1"));
+      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, bytes32("redeem1"));
 
     // bob relays alice's signed authorization
     vm.prank(bob);
     (address[] memory tokens, uint256[] memory amounts) =
-      parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, authData);
+      parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, authData);
 
     assertEq(tokens.length, 3);
     for (uint256 i; i < amounts.length; i++) {
@@ -1925,46 +1984,62 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256 redeemAmount = tokenP.balanceOf(alice) / 4;
 
-    vm.startPrank(guardian);
-    uint64[] memory xR = new uint64[](1);
-    xR[0] = uint64(0);
-    int64[] memory yR = new int64[](1);
-    yR[0] = int64(int256(BASE_9));
-    parallelizer.setRedemptionCurveParams(xR, yR);
-    vm.stopPrank();
+    {
+      vm.startPrank(guardian);
+      uint64[] memory xR = new uint64[](1);
+      xR[0] = uint64(0);
+      int64[] memory yR = new int64[](1);
+      yR[0] = int64(int256(BASE_9));
+      parallelizer.setRedemptionCurveParams(xR, yR);
+      vm.stopPrank();
+    }
 
     uint256 deadline = block.timestamp + 1 hours;
     uint256[] memory minOuts = new uint256[](3);
+    tokensHash = _redemptionTokensHash(redeemAmount);
     address[] memory forfeit = new address[](0);
-    bytes memory aliceAuth =
-      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, bytes32("redeem_frontrun"));
+    bytes memory aliceAuth = _buildRedeemAuth(
+      1, alice, redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, bytes32("redeem_frontrun")
+    );
 
     vm.prank(bob);
     vm.expectRevert(bytes("invalid signature"));
-    parallelizer.redeemWithAuthorization(redeemAmount, bob, deadline, minOuts, forfeit, aliceAuth);
+    parallelizer.redeemWithAuthorization(redeemAmount, bob, deadline, minOuts, forfeit, tokensHash, aliceAuth);
   }
 
   function test_RedeemWithAuthorization_RevertWhen_ValueMismatch() public {
     _mintExactInput(alice, address(eurA), 100 * BASE_6, 0);
     uint256 redeemAmount = tokenP.balanceOf(alice) / 4;
 
-    vm.startPrank(guardian);
-    uint64[] memory xR = new uint64[](1);
-    xR[0] = uint64(0);
-    int64[] memory yR = new int64[](1);
-    yR[0] = int64(int256(BASE_9));
-    parallelizer.setRedemptionCurveParams(xR, yR);
-    vm.stopPrank();
+    {
+      vm.startPrank(guardian);
+      uint64[] memory xR = new uint64[](1);
+      xR[0] = uint64(0);
+      int64[] memory yR = new int64[](1);
+      yR[0] = int64(int256(BASE_9));
+      parallelizer.setRedemptionCurveParams(xR, yR);
+      vm.stopPrank();
+    }
 
     uint256 deadline = block.timestamp + 1 hours;
     uint256[] memory minOuts = new uint256[](3);
+    tokensHash = _redemptionTokensHash(redeemAmount);
     address[] memory forfeit = new address[](0);
-    bytes memory authData =
-      _buildRedeemAuth(1, alice, redeemAmount / 2, alice, deadline, minOuts, forfeit, bytes32("bad_redeem"));
+    bytes memory authData = _buildRedeemAuth(
+      1,
+      alice,
+      redeemAmount / 2,
+      alice,
+      deadline,
+      minOuts,
+      forfeit,
+      _redemptionTokensHash(redeemAmount / 2),
+      bytes32("bad_redeem")
+    );
 
     vm.prank(bob);
     vm.expectRevert();
-    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, authData);
+    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, authData);
   }
 
   function test_RedeemWithAuthorization_RevertWhen_ReusedNonce() public {
@@ -1975,27 +2050,32 @@ contract RedeemTest is Fixture, FunctionUtils {
     uint256 redeemAmount = tokenP.balanceOf(alice) / 8;
     bytes32 userSalt = bytes32("reuse_redeem");
 
-    vm.startPrank(guardian);
-    uint64[] memory xR = new uint64[](1);
-    xR[0] = uint64(0);
-    int64[] memory yR = new int64[](1);
-    yR[0] = int64(int256(BASE_9));
-    parallelizer.setRedemptionCurveParams(xR, yR);
-    vm.stopPrank();
+    {
+      vm.startPrank(guardian);
+      uint64[] memory xR = new uint64[](1);
+      xR[0] = uint64(0);
+      int64[] memory yR = new int64[](1);
+      yR[0] = int64(int256(BASE_9));
+      parallelizer.setRedemptionCurveParams(xR, yR);
+      vm.stopPrank();
+    }
 
     uint256 deadline = block.timestamp + 1 hours;
     uint256[] memory minOuts = new uint256[](3);
+    tokensHash = _redemptionTokensHash(redeemAmount);
     address[] memory forfeit = new address[](0);
-    bytes memory authData1 = _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, userSalt);
+    bytes memory authData1 =
+      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, userSalt);
 
     vm.prank(bob);
-    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, authData1);
+    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, authData1);
 
-    bytes memory authData2 = _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, userSalt);
+    bytes memory authData2 =
+      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, userSalt);
 
     vm.prank(bob);
     vm.expectRevert();
-    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, authData2);
+    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, authData2);
   }
 
   event Redeemed(
@@ -2014,27 +2094,30 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256 redeemAmount = tokenP.balanceOf(alice) / 4;
 
-    vm.startPrank(guardian);
-    uint64[] memory xR = new uint64[](1);
-    xR[0] = uint64(0);
-    int64[] memory yR = new int64[](1);
-    yR[0] = int64(int256(BASE_9));
-    parallelizer.setRedemptionCurveParams(xR, yR);
-    vm.stopPrank();
+    {
+      vm.startPrank(guardian);
+      uint64[] memory xR = new uint64[](1);
+      xR[0] = uint64(0);
+      int64[] memory yR = new int64[](1);
+      yR[0] = int64(int256(BASE_9));
+      parallelizer.setRedemptionCurveParams(xR, yR);
+      vm.stopPrank();
+    }
 
     uint256 deadline = block.timestamp + 1 hours;
     uint256[] memory minOuts = new uint256[](3);
+    tokensHash = _redemptionTokensHash(redeemAmount);
     address[] memory forfeit = new address[](1);
     forfeit[0] = address(eurA);
 
     bytes memory authData =
-      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, bytes32("forfeit_ok"));
+      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, bytes32("forfeit_ok"));
 
     uint256 eurABefore = IERC20(address(eurA)).balanceOf(alice);
     uint256 eurBBefore = IERC20(address(eurB)).balanceOf(alice);
 
     vm.prank(bob);
-    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, authData);
+    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, authData);
 
     assertEq(IERC20(address(eurA)).balanceOf(alice), eurABefore, "forfeited token must not be transferred");
     assertGt(IERC20(address(eurB)).balanceOf(alice), eurBBefore, "non-forfeited token must be transferred");
@@ -2047,28 +2130,32 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256 redeemAmount = tokenP.balanceOf(alice) / 4;
 
-    vm.startPrank(guardian);
-    uint64[] memory xR = new uint64[](1);
-    xR[0] = uint64(0);
-    int64[] memory yR = new int64[](1);
-    yR[0] = int64(int256(BASE_9));
-    parallelizer.setRedemptionCurveParams(xR, yR);
-    vm.stopPrank();
+    {
+      vm.startPrank(guardian);
+      uint64[] memory xR = new uint64[](1);
+      xR[0] = uint64(0);
+      int64[] memory yR = new int64[](1);
+      yR[0] = int64(int256(BASE_9));
+      parallelizer.setRedemptionCurveParams(xR, yR);
+      vm.stopPrank();
+    }
 
     uint256 deadline = block.timestamp + 1 hours;
     uint256[] memory minOuts = new uint256[](3);
+    tokensHash = _redemptionTokensHash(redeemAmount);
 
     address[] memory signedForfeit = new address[](1);
     signedForfeit[0] = address(eurA);
-    bytes memory authData =
-      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, signedForfeit, bytes32("forfeit_bind"));
+    bytes memory authData = _buildRedeemAuth(
+      1, alice, redeemAmount, alice, deadline, minOuts, signedForfeit, tokensHash, bytes32("forfeit_bind")
+    );
 
     address[] memory tamperedForfeit = new address[](1);
     tamperedForfeit[0] = address(eurB);
 
     vm.prank(bob);
     vm.expectRevert(bytes("invalid signature"));
-    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, tamperedForfeit, authData);
+    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, tamperedForfeit, tokensHash, authData);
   }
 
   function test_RedeemWithAuthorization_EmitsAuthorizerNotRelayer() public {
@@ -2078,24 +2165,28 @@ contract RedeemTest is Fixture, FunctionUtils {
 
     uint256 redeemAmount = tokenP.balanceOf(alice) / 4;
 
-    vm.startPrank(guardian);
-    uint64[] memory xR = new uint64[](1);
-    xR[0] = uint64(0);
-    int64[] memory yR = new int64[](1);
-    yR[0] = int64(int256(BASE_9));
-    parallelizer.setRedemptionCurveParams(xR, yR);
-    vm.stopPrank();
+    {
+      vm.startPrank(guardian);
+      uint64[] memory xR = new uint64[](1);
+      xR[0] = uint64(0);
+      int64[] memory yR = new int64[](1);
+      yR[0] = int64(int256(BASE_9));
+      parallelizer.setRedemptionCurveParams(xR, yR);
+      vm.stopPrank();
+    }
 
     uint256 deadline = block.timestamp + 1 hours;
     uint256[] memory minOuts = new uint256[](3);
+    tokensHash = _redemptionTokensHash(redeemAmount);
     address[] memory forfeit = new address[](0);
-    bytes memory authData =
-      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, bytes32("event_attr_redeem"));
+    bytes memory authData = _buildRedeemAuth(
+      1, alice, redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, bytes32("event_attr_redeem")
+    );
 
     vm.expectEmit(true, true, false, false, address(parallelizer));
     emit Redeemed(0, new address[](0), new uint256[](0), new address[](0), alice, alice);
 
     vm.prank(bob);
-    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, authData);
+    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, tokensHash, authData);
   }
 }
diff --git a/tests/invariants/actors/Arbitrager.t.sol b/tests/invariants/actors/Arbitrager.t.sol
index cd586c8..310038f 100644
--- a/tests/invariants/actors/Arbitrager.t.sol
+++ b/tests/invariants/actors/Arbitrager.t.sol
@@ -3,7 +3,12 @@ pragma solidity 0.8.28;
 
 import "contracts/utils/Constants.sol";
 import {
-  AggregatorV3Interface, BaseActor, IERC20, IERC20Metadata, IParallelizer, TestStorage
+  AggregatorV3Interface,
+  BaseActor,
+  IERC20,
+  IERC20Metadata,
+  IParallelizer,
+  TestStorage
 } from "./BaseActor.t.sol";
 import { QuoteType } from "contracts/parallelizer/Storage.sol";
 import { console } from "@forge-std/console.sol";
@@ -185,8 +190,9 @@ contract Arbitrager is BaseActor {
         // don't care about slippage
         uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
         address[] memory redeemTokens;
+        bytes32 tokensHash = _redemptionTokensHash(_parallelizer, amount);
         (redeemTokens, redeemAmounts) = _parallelizer.redeemWithForfeit(
-          amount, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens
+          amount, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens, tokensHash
         );
       }
 
diff --git a/tests/invariants/actors/ArbitragerWithSplit.t.sol b/tests/invariants/actors/ArbitragerWithSplit.t.sol
index 8a54e49..0ee4a8e 100644
--- a/tests/invariants/actors/ArbitragerWithSplit.t.sol
+++ b/tests/invariants/actors/ArbitragerWithSplit.t.sol
@@ -3,7 +3,12 @@ pragma solidity 0.8.28;
 
 import "contracts/utils/Constants.sol";
 import {
-  AggregatorV3Interface, BaseActor, IERC20, IERC20Metadata, IParallelizer, TestStorage
+  AggregatorV3Interface,
+  BaseActor,
+  IERC20,
+  IERC20Metadata,
+  IParallelizer,
+  TestStorage
 } from "./BaseActor.t.sol";
 import { QuoteType } from "contracts/parallelizer/Storage.sol";
 import { console } from "@forge-std/console.sol";
@@ -260,8 +265,9 @@ contract ArbitragerWithSplit is BaseActor {
         // don't care about slippage
         uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
         address[] memory redeemTokens;
+        bytes32 tokensHash = _redemptionTokensHash(_parallelizer, amount);
         (redeemTokens, redeemAmounts) = _parallelizer.redeemWithForfeit(
-          amount, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens
+          amount, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens, tokensHash
         );
       }
 
@@ -298,12 +304,14 @@ contract ArbitragerWithSplit is BaseActor {
         address[] memory redeemTokens;
 
         uint256 amountSplit = (amount * splitProportion) / BASE_9;
+        bytes32 tokensHash = _redemptionTokensHash(_parallelizerSplit, amountSplit);
         (redeemTokens, redeemAmountsSplit1) = _parallelizerSplit.redeemWithForfeit(
-          amountSplit, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens
+          amountSplit, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens, tokensHash
         );
         amountSplit = amount - amountSplit;
+        tokensHash = _redemptionTokensHash(_parallelizerSplit, amountSplit);
         (, redeemAmountsSplit2) = _parallelizerSplit.redeemWithForfeit(
-          amountSplit, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens
+          amountSplit, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens, tokensHash
         );
       }
 
diff --git a/tests/invariants/actors/BaseActor.t.sol b/tests/invariants/actors/BaseActor.t.sol
index e4fdd05..cb0e37f 100644
--- a/tests/invariants/actors/BaseActor.t.sol
+++ b/tests/invariants/actors/BaseActor.t.sol
@@ -79,4 +79,11 @@ contract BaseActor is Test {
     _maxTokenAmount.push(_maxAmountWithoutDecimals * 10 ** IERC20Metadata(_collaterals[1]).decimals());
     _maxTokenAmount.push(_maxAmountWithoutDecimals * 10 ** IERC20Metadata(_collaterals[2]).decimals());
   }
+
+  /// @dev The output list a redemption of `amount` would produce right now, hashed as the redeem
+  /// entry points expect it
+  function _redemptionTokensHash(IParallelizer target, uint256 amount) internal view returns (bytes32) {
+    (address[] memory tokens,) = target.quoteRedemptionCurve(amount);
+    return keccak256(abi.encodePacked(tokens));
+  }
 }
diff --git a/tests/mock/MockReentrant.sol b/tests/mock/MockReentrant.sol
index 19e1a98..719657c 100644
--- a/tests/mock/MockReentrant.sol
+++ b/tests/mock/MockReentrant.sol
@@ -19,10 +19,11 @@ contract ReentrantRedeemGetCollateralRatio {
   }
 
   function testERC777Reentrancy(uint256 redeemAmount) public {
-    uint256[] memory minAmountOuts;
-    (, uint256[] memory quoteAmounts) = parallelizer.quoteRedemptionCurve(redeemAmount);
-    minAmountOuts = new uint256[](quoteAmounts.length);
-    parallelizer.redeem(redeemAmount, address(this), block.timestamp * 2, minAmountOuts);
+    (address[] memory quoteTokens, uint256[] memory quoteAmounts) = parallelizer.quoteRedemptionCurve(redeemAmount);
+    uint256[] memory minAmountOuts = new uint256[](quoteAmounts.length);
+    parallelizer.redeem(
+      redeemAmount, address(this), block.timestamp * 2, minAmountOuts, keccak256(abi.encodePacked(quoteTokens))
+    );
   }
 
   function setInterfaceImplementer() public {
@@ -60,10 +61,11 @@ contract ReentrantRedeemSwap {
   }
 
   function testERC777Reentrancy(uint256 redeemAmount) public {
-    uint256[] memory minAmountOuts;
-    (, uint256[] memory quoteAmounts) = parallelizer.quoteRedemptionCurve(redeemAmount);
-    minAmountOuts = new uint256[](quoteAmounts.length);
-    parallelizer.redeem(redeemAmount, address(this), block.timestamp * 2, minAmountOuts);
+    (address[] memory quoteTokens, uint256[] memory quoteAmounts) = parallelizer.quoteRedemptionCurve(redeemAmount);
+    uint256[] memory minAmountOuts = new uint256[](quoteAmounts.length);
+    parallelizer.redeem(
+      redeemAmount, address(this), block.timestamp * 2, minAmountOuts, keccak256(abi.encodePacked(quoteTokens))
+    );
   }
 
   function setInterfaceImplementer() public {
diff --git a/tests/units/RedemptionTokenBinding.t.sol b/tests/units/RedemptionTokenBinding.t.sol
new file mode 100644
index 0000000..298b762
--- /dev/null
+++ b/tests/units/RedemptionTokenBinding.t.sol
@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity 0.8.28;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+import { Fixture } from "../Fixture.sol";
+import { OracleReadType } from "contracts/parallelizer/Storage.sol";
+import "contracts/utils/Constants.sol";
+import "contracts/utils/Errors.sol" as Errors;
+
+/// @notice The redemption output list is rebuilt from the live `collateralList`, while `minAmountOuts`
+/// is positional. A revoke (swap and pop) followed by an add preserves the length but reshuffles the
+/// tokens, so a caller's minima would end up guarding tokens they never quoted.
+contract Test_RedemptionTokenBinding is Fixture {
+  uint256 internal redeemAmount;
+
+  function setUp() public override {
+    super.setUp();
+
+    // eurB stays unbacked so governance is allowed to revoke it
+    _mintExactInput(alice, address(eurA), 100 * BASE_6, 0);
+    _mintExactInput(alice, address(eurY), 100 * BASE_18, 0);
+
+    uint64[] memory xRedemption = new uint64[](1);
+    int64[] memory yRedemption = new int64[](1);
+    yRedemption[0] = int64(int256(BASE_9));
+    hoax(guardian);
+    parallelizer.setRedemptionCurveParams(xRedemption, yRedemption);
+
+    redeemAmount = tokenP.balanceOf(alice) / 4;
+  }
+
+  function _tokensHash() internal view returns (bytes32) {
+    (address[] memory tokens,) = parallelizer.quoteRedemptionCurve(redeemAmount);
+    return keccak256(abi.encodePacked(tokens));
+  }
+
+  /// @dev Revoking eurB pops eurY into its slot, and adding eurB back appends it: same length,
+  /// different order
+  function _rotateCollateral() internal {
+    (
+      OracleReadType oracleType,
+      OracleReadType targetType,
+      bytes memory oracleData,
+      bytes memory targetData,
+      bytes memory hyperparameters
+    ) = parallelizer.getOracle(address(eurB));
+
+    hoax(governor);
+    parallelizer.revokeCollateral(address(eurB), true);
+    hoax(governor);
+    parallelizer.addCollateral(address(eurB));
+    hoax(governor);
+    parallelizer.setOracle(
+      address(eurB), abi.encode(oracleType, targetType, oracleData, targetData, hyperparameters)
+    );
+  }
+
+  function test_Redeem_SucceedsWhenTheOutputListMatches() public {
+    uint256[] memory minAmountOuts = new uint256[](3);
+    bytes32 quotedHash = _tokensHash();
+
+    vm.prank(alice);
+    (address[] memory tokens,) =
+      parallelizer.redeem(redeemAmount, alice, block.timestamp + 1 days, minAmountOuts, quotedHash);
+
+    assertEq(tokens.length, 3);
+  }
+
+  function test_RevertWhen_CollateralRotationReordersTheOutputList() public {
+    bytes32 quotedHash = _tokensHash();
+    (address[] memory quotedTokens,) = parallelizer.quoteRedemptionCurve(redeemAmount);
+
+    _rotateCollateral();
+
+    (address[] memory liveTokens,) = parallelizer.quoteRedemptionCurve(redeemAmount);
+    assertEq(liveTokens.length, quotedTokens.length, "the rotation must preserve the length");
+    assertNotEq(liveTokens[1], quotedTokens[1], "the rotation must reorder the list");
+
+    uint256[] memory minAmountOuts = new uint256[](3);
+    vm.prank(alice);
+    vm.expectRevert(Errors.UnexpectedRedemptionTokens.selector);
+    parallelizer.redeem(redeemAmount, alice, block.timestamp + 1 days, minAmountOuts, quotedHash);
+  }
+
+  /// @dev A signature stays executable for its whole validity window, so a relayer could otherwise
+  /// hold one until governance reshuffles the list
+  function test_RevertWhen_AuthorizationOutlivesTheOutputList() public {
+    uint256 deadline = block.timestamp + 1 hours;
+    uint256[] memory minOuts = new uint256[](3);
+    address[] memory forfeit = new address[](0);
+    bytes32 quotedHash = _tokensHash();
+
+    bytes memory authData =
+      _buildRedeemAuth(1, alice, redeemAmount, alice, deadline, minOuts, forfeit, quotedHash, bytes32("rotate"));
+
+    _rotateCollateral();
+
+    // The relayer cannot satisfy the on-chain check with what was signed
+    vm.prank(bob);
+    vm.expectRevert(Errors.UnexpectedRedemptionTokens.selector);
+    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, quotedHash, authData);
+
+    // Nor swap in the live list, which no longer derives the signed nonce
+    bytes32 liveHash = _tokensHash();
+    vm.prank(bob);
+    vm.expectRevert(bytes("invalid signature"));
+    parallelizer.redeemWithAuthorization(redeemAmount, alice, deadline, minOuts, forfeit, liveHash, authData);
+  }
+}
diff --git a/tests/units/Setters.t.sol b/tests/units/Setters.t.sol
index fe542bc..5e251e0 100644
--- a/tests/units/Setters.t.sol
+++ b/tests/units/Setters.t.sol
@@ -80,10 +80,12 @@ contract Test_Setters_Pause is Fixture {
     assert(parallelizer.isPaused(address(eurA), ActionType.Redeem));
 
     vm.expectRevert(Errors.Paused.selector);
-    parallelizer.redeem(1 ether, alice, block.timestamp + 10, new uint256[](3));
+    parallelizer.redeem(1 ether, alice, block.timestamp + 10, new uint256[](3), bytes32(0));
 
     vm.expectRevert(Errors.Paused.selector);
-    parallelizer.redeemWithForfeit(1 ether, alice, block.timestamp + 10, new uint256[](3), new address[](0));
+    parallelizer.redeemWithForfeit(
+      1 ether, alice, block.timestamp + 10, new uint256[](3), new address[](0), bytes32(0)
+    );
   }
 }
 

From 7cceca756adb5842129820157dfe115428af9065 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 18:07:54 +0300
Subject: [PATCH 15/38] test(invariants): make the path independence suite
 measure path independence

`invariant_PathIndependenceCollateralRatio` failed once during the audit work at
0.2176% against a 0.2% tolerance. The driver was not the documented one.

`ArbitragerWithSplit` split a redemption that forfeited tokens. Forfeited tokens
stay in the reserve while the others shrink, so the composition drifts and each
later redemption forfeits a larger share of value. Measured against a plain
redemption split the same way:

  splits          2      4      8     16
  no forfeit      0      0      0      0   bps
  forfeit B     193    289    337    360   bps
  forfeit B+Y   146    209    238    252   bps

So a single split already sat an order of magnitude above the tolerance, and the
suite only passed because the fuzzer rarely landed a large forfeited redemption.
The comment credited non-flat fee curves and the entry-time penalty, both of
which measure zero here.

Forfeit is what breaks the comparison when split, not forfeit itself, so it moves
to its own `redeemWithForfeit` handler that applies the same unsplit redemption to
both systems. They drift together, the forfeit branch and its payout assertions
stay covered, and only the plain redemption is split.

Across 25 seeded campaigns the residual divergence peaks at 1.4e-8%, down from
4.1e-6%, so the collateral ratio tolerance drops from 0.2% to 0.01%, matching the
total supply one.
---
 tests/invariants/PathIndeInvariants.t.sol     |  21 +++-
 .../actors/ArbitragerWithSplit.t.sol          | 109 +++++++++++++-----
 2 files changed, 96 insertions(+), 34 deletions(-)

diff --git a/tests/invariants/PathIndeInvariants.t.sol b/tests/invariants/PathIndeInvariants.t.sol
index 8440a31..1a0c634 100644
--- a/tests/invariants/PathIndeInvariants.t.sol
+++ b/tests/invariants/PathIndeInvariants.t.sol
@@ -114,9 +114,10 @@ contract PathIndeInvariants is Fixture {
     }
 
     {
-      bytes4[] memory selectors = new bytes4[](2);
+      bytes4[] memory selectors = new bytes4[](3);
       selectors[0] = ArbitragerWithSplit.swap.selector;
       selectors[1] = ArbitragerWithSplit.redeem.selector;
+      selectors[2] = ArbitragerWithSplit.redeemWithForfeit.selector;
       targetSelector(FuzzSelector({ addr: address(_arbitragerHandler), selectors: selectors }));
     }
 
@@ -139,6 +140,7 @@ contract PathIndeInvariants is Fixture {
     console.log("Trader:swap", _traderHandler.calls("swap"));
     console.log("Arbitrager:swap", _arbitragerHandler.calls("swap"));
     console.log("Arbitrager:redeem", _arbitragerHandler.calls("redeem"));
+    console.log("Arbitrager:redeemForfeit", _arbitragerHandler.calls("redeemForfeit"));
     console.log("oracle", _governanceHandler.calls("oracle"));
     console.log("Mint fees", _governanceHandler.calls("feeMint"));
     console.log("Burn fees", _governanceHandler.calls("feeBurn"));
@@ -216,21 +218,28 @@ contract PathIndeInvariants is Fixture {
   // Path independence holds exactly only where the mint/burn/redemption curves are flat. The
   // redemption penalty is evaluated at the entry-time collateral ratio on the full amount (Cyfrin
   // finding I-6) and governance may install non-flat fee curves, so single-path and split-path
-  // outcomes legitimately diverge by a bounded amount. These tolerances bound that intended path
-  // dependence (1% on collateral balances, 0.2% on the collateral ratio) while still catching gross
-  // path-dependence regressions.
+  // outcomes legitimately diverge by a bounded amount.
+  //
+  // The dominant source used to be elsewhere: `ArbitragerWithSplit` split a redemption that forfeited
+  // tokens. Forfeited tokens stay in the reserve while the others shrink, so the composition drifts
+  // and each later redemption forfeits a larger share of value. Splitting one moved the collateral
+  // ratio by 150 to 200 bps, an order of magnitude past this tolerance.
+  //
+  // Forfeit is still exercised, through `redeemWithForfeit`, but applied identically and unsplit to
+  // both systems so they drift together. Only the plain redemption is split. The residual divergence
+  // measured over 25 seeded campaigns peaks at 1.4e-8%, against 4.1e-6% before.
   function invariant_PathIndependenceBalanceCollaterals() public {
     for (uint256 i; i < _collaterals.length; i++) {
       uint256 balance = IERC20(_collaterals[i]).balanceOf(address(parallelizer));
       uint256 balanceSplit = IERC20(_collaterals[i]).balanceOf(address(parallelizerSplit));
-      assertApproxEqRelDecimal(balance, balanceSplit, _MAX_PERCENTAGE_DEVIATION * 10000, 18);
+      assertApproxEqRelDecimal(balance, balanceSplit, _MAX_PERCENTAGE_DEVIATION * 10_000, 18);
     }
   }
 
   function invariant_PathIndependenceCollateralRatio() public {
     (uint256 collateralRatio,) = parallelizer.getCollateralRatio();
     (uint256 collateralRatioSplit,) = parallelizerSplit.getCollateralRatio();
-    assertApproxEqRelDecimal(collateralRatio, collateralRatioSplit, _MAX_PERCENTAGE_DEVIATION * 2000, 18);
+    assertApproxEqRelDecimal(collateralRatio, collateralRatioSplit, _MAX_PERCENTAGE_DEVIATION * 100, 18);
   }
 
   function invariantSystemState() public view {
diff --git a/tests/invariants/actors/ArbitragerWithSplit.t.sol b/tests/invariants/actors/ArbitragerWithSplit.t.sol
index 0ee4a8e..e7ee4ec 100644
--- a/tests/invariants/actors/ArbitragerWithSplit.t.sol
+++ b/tests/invariants/actors/ArbitragerWithSplit.t.sol
@@ -217,23 +217,23 @@ contract ArbitragerWithSplit is BaseActor {
     return (testS.amountIn, testS.amountOut);
   }
 
-  function redeem(
+  /// @dev Forfeit is exercised here, but applied identically and unsplit to both systems, so they
+  /// drift together and the path independence invariants stay meaningful. Splitting a forfeited
+  /// redemption is what breaks them: the forfeited tokens stay in the reserve while the others
+  /// shrink, so the composition drifts and each later redemption forfeits a larger share of value.
+  function redeemWithForfeit(
     bool[3] memory isForfeitTokens,
     uint256 amount,
-    uint256 splitProportion,
     uint256 actorIndex
   )
     public
     useActor(actorIndex)
-    countCall("redeem")
+    countCall("redeemForfeit")
   {
     uint256 balancetokenP = tokenP.balanceOf(_currentActor);
     amount = bound(amount, 0, balancetokenP / 2);
-    splitProportion = bound(splitProportion, 1, BASE_9);
     if (amount == 0) return;
 
-    // Build forfeitTokens from isForfeitTokens so the protocol skips them; the post-redeem
-    // assertions below assume forfeited tokens are not credited to the actor.
     address[] memory forfeitTokens;
     {
       uint256 count;
@@ -249,6 +249,70 @@ contract ArbitragerWithSplit is BaseActor {
         }
       }
     }
+    if (forfeitTokens.length == 0) return;
+
+    console.log("");
+    console.log("========= Redeem With Forfeit =========");
+
+    _redeemForfeitOn(_parallelizer, amount, isForfeitTokens, forfeitTokens);
+    _redeemForfeitOn(_parallelizerSplit, amount, isForfeitTokens, forfeitTokens);
+  }
+
+  /// @dev Extracted so the caller stays within the EVM stack-depth limit
+  function _redeemForfeitOn(
+    IParallelizer target,
+    uint256 amount,
+    bool[3] memory isForfeitTokens,
+    address[] memory forfeitTokens
+  )
+    internal
+  {
+    uint256[] memory balanceTokens = new uint256[](_collaterals.length);
+    for (uint256 i; i < balanceTokens.length; ++i) {
+      balanceTokens[i] = IERC20(_collaterals[i]).balanceOf(_currentActor);
+    }
+
+    (uint64 prevCollateralRatio,) = target.getCollateralRatio();
+    uint256[] memory redeemAmounts;
+    {
+      uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
+      bytes32 tokensHash = _redemptionTokensHash(target, amount);
+      (, redeemAmounts) = target.redeemWithForfeit(
+        amount, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens, tokensHash
+      );
+    }
+
+    // forfeiting leaves value behind, so the ratio can only improve
+    (uint64 collateralRatio,) = target.getCollateralRatio();
+    assertGe(collateralRatio, prevCollateralRatio);
+    for (uint256 i; i < balanceTokens.length; ++i) {
+      if (isForfeitTokens[i]) {
+        assertEq(IERC20(_collaterals[i]).balanceOf(_currentActor), balanceTokens[i]);
+      } else {
+        assertEq(IERC20(_collaterals[i]).balanceOf(_currentActor), balanceTokens[i] + redeemAmounts[i]);
+      }
+    }
+  }
+
+  /// @dev No forfeit here, unlike the non-split `Arbitrager`. Forfeited tokens stay in the reserve
+  /// while the others shrink, so the composition drifts and each later redemption forfeits a larger
+  /// share of value. That makes redemption genuinely path dependent: a single split moves the
+  /// collateral ratio by around 150 to 200 bps against 0 for a plain redemption, which is what the
+  /// path independence invariants measure. `Arbitrager` keeps the forfeit coverage for the other suites.
+  function redeem(
+    uint256 amount,
+    uint256 splitProportion,
+    uint256 actorIndex
+  )
+    public
+    useActor(actorIndex)
+    countCall("redeem")
+  {
+    uint256 balancetokenP = tokenP.balanceOf(_currentActor);
+    amount = bound(amount, 0, balancetokenP / 2);
+    splitProportion = bound(splitProportion, 1, BASE_9);
+    if (amount == 0) return;
+
     // Redeem on the true parallelizer
     {
       uint256[] memory balanceTokens = new uint256[](_collaterals.length);
@@ -264,11 +328,9 @@ contract ArbitragerWithSplit is BaseActor {
       {
         // don't care about slippage
         uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
-        address[] memory redeemTokens;
         bytes32 tokensHash = _redemptionTokensHash(_parallelizer, amount);
-        (redeemTokens, redeemAmounts) = _parallelizer.redeemWithForfeit(
-          amount, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens, tokensHash
-        );
+        (, redeemAmounts) =
+          _parallelizer.redeem(amount, _currentActor, block.timestamp + 1 hours, minAmountOuts, tokensHash);
       }
 
       // if it is a burn it should always increase the collateral ratio
@@ -277,11 +339,7 @@ contract ArbitragerWithSplit is BaseActor {
       assertEq(tokenP.balanceOf(_currentActor), balancetokenP - amount);
       balancetokenP -= amount;
       for (uint256 i; i < balanceTokens.length; ++i) {
-        if (!isForfeitTokens[i]) {
-          assertEq(IERC20(_collaterals[i]).balanceOf(_currentActor), balanceTokens[i] + redeemAmounts[i]);
-        } else {
-          assertEq(IERC20(_collaterals[i]).balanceOf(_currentActor), balanceTokens[i]);
-        }
+        assertEq(IERC20(_collaterals[i]).balanceOf(_currentActor), balanceTokens[i] + redeemAmounts[i]);
       }
     }
 
@@ -301,17 +359,16 @@ contract ArbitragerWithSplit is BaseActor {
       {
         // don't care about slippage
         uint256[] memory minAmountOuts = new uint256[](_collaterals.length);
-        address[] memory redeemTokens;
 
         uint256 amountSplit = (amount * splitProportion) / BASE_9;
         bytes32 tokensHash = _redemptionTokensHash(_parallelizerSplit, amountSplit);
-        (redeemTokens, redeemAmountsSplit1) = _parallelizerSplit.redeemWithForfeit(
-          amountSplit, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens, tokensHash
+        (, redeemAmountsSplit1) = _parallelizerSplit.redeem(
+          amountSplit, _currentActor, block.timestamp + 1 hours, minAmountOuts, tokensHash
         );
         amountSplit = amount - amountSplit;
         tokensHash = _redemptionTokensHash(_parallelizerSplit, amountSplit);
-        (, redeemAmountsSplit2) = _parallelizerSplit.redeemWithForfeit(
-          amountSplit, _currentActor, block.timestamp + 1 hours, minAmountOuts, forfeitTokens, tokensHash
+        (, redeemAmountsSplit2) = _parallelizerSplit.redeem(
+          amountSplit, _currentActor, block.timestamp + 1 hours, minAmountOuts, tokensHash
         );
       }
 
@@ -320,14 +377,10 @@ contract ArbitragerWithSplit is BaseActor {
       assertGe(collateralRatio, prevCollateralRatio);
       assertEq(tokenP.balanceOf(_currentActor), balancetokenP - amount);
       for (uint256 i; i < balanceTokens.length; ++i) {
-        if (!isForfeitTokens[i]) {
-          assertEq(
-            IERC20(_collaterals[i]).balanceOf(_currentActor),
-            balanceTokens[i] + redeemAmountsSplit1[i] + redeemAmountsSplit2[i]
-          );
-        } else {
-          assertEq(IERC20(_collaterals[i]).balanceOf(_currentActor), balanceTokens[i]);
-        }
+        assertEq(
+          IERC20(_collaterals[i]).balanceOf(_currentActor),
+          balanceTokens[i] + redeemAmountsSplit1[i] + redeemAmountsSplit2[i]
+        );
       }
     }
   }

From 5710e3cd6d6db88a2f0ba7c1bfdf84bece3de973 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 21:41:41 +0300
Subject: [PATCH 16/38] perf(rebalancer): pack the yield bearing params into
 two slots

`maxSlippage` was a uint96, a width inherited from the Angle fork where it was a
standalone variable that had a slot to itself. Inside `YieldBearingParams` its 12
bytes no longer fit beside the four uint64 exposures, so it spilled into a third
slot and left 20 bytes unused.

The value is bounded below 1e9, so uint64 is ample and closes the second slot
exactly:

  asset             slot 0  offset  0
  targetExposure    slot 0  offset 20
  maxExposure       slot 1  offset  0
  minExposure       slot 1  offset  8
  overrideExposures slot 1  offset 16
  maxSlippage       slot 1  offset 24

Configuring an asset drops from 104588 to 82501 gas.
---
 contracts/helpers/BaseRebalancer.sol       | 13 +++++++------
 contracts/helpers/MultiBlockRebalancer.sol |  2 +-
 contracts/interfaces/IRebalancer.sol       |  4 ++--
 tests/units/Rebalancer.t.sol               |  2 +-
 4 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/contracts/helpers/BaseRebalancer.sol b/contracts/helpers/BaseRebalancer.sol
index b9d22a6..19abd87 100644
--- a/contracts/helpers/BaseRebalancer.sol
+++ b/contracts/helpers/BaseRebalancer.sol
@@ -22,8 +22,9 @@ struct YieldBearingParams {
   // Whether limit exposures should be overriden or read onchain through the Parallelizer
   // This value should be 1 to override exposures or 2 if these shouldn't be overriden
   uint64 overrideExposures;
-  // Maximum slippage when dealing with the Parallelizer
-  uint96 maxSlippage;
+  // Maximum slippage when dealing with the Parallelizer, bounded below 1e9 so uint64 leaves the
+  // struct packed in two slots
+  uint64 maxSlippage;
 }
 
 /// @title BaseRebalancer
@@ -115,7 +116,7 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
     uint64 minExposure,
     uint64 maxExposure,
     uint64 overrideExposures,
-    uint96 maxSlippage
+    uint64 maxSlippage
   )
     external
     restricted
@@ -140,7 +141,7 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
    * @notice Set the max allowed slippage
    * @param newMaxSlippage new max allowed slippage
    */
-  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external restricted {
+  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external restricted {
     _setMaxSlippage(yieldBearingAsset, newMaxSlippage);
   }
 
@@ -252,7 +253,7 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
     uint64 minExposure,
     uint64 maxExposure,
     uint64 overrideExposures,
-    uint96 maxSlippage
+    uint64 maxSlippage
   )
     internal
     virtual
@@ -301,7 +302,7 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
     else yieldBearingInfo.minExposure = xFeeBurn[length - 2];
   }
 
-  function _setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) internal virtual {
+  function _setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) internal virtual {
     if (newMaxSlippage >= 1e9) revert InvalidParam();
     yieldBearingData[yieldBearingAsset].maxSlippage = newMaxSlippage;
   }
diff --git a/contracts/helpers/MultiBlockRebalancer.sol b/contracts/helpers/MultiBlockRebalancer.sol
index 8edd3f5..172ab3c 100644
--- a/contracts/helpers/MultiBlockRebalancer.sol
+++ b/contracts/helpers/MultiBlockRebalancer.sol
@@ -148,7 +148,7 @@ contract MultiBlockRebalancer is BaseRebalancer {
     address asset,
     address depositAddress,
     bool assetIn,
-    uint96 maxSlippage
+    uint64 maxSlippage
   )
     internal
     view
diff --git a/contracts/interfaces/IRebalancer.sol b/contracts/interfaces/IRebalancer.sol
index 6991e60..5a33c3a 100644
--- a/contracts/interfaces/IRebalancer.sol
+++ b/contracts/interfaces/IRebalancer.sol
@@ -14,13 +14,13 @@ interface IRebalancer {
     uint64 minExposureYieldAsset,
     uint64 maxExposureYieldAsset,
     uint64 overrideExposures,
-    uint96 maxSlippage
+    uint64 maxSlippage
   )
     external;
 
   function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;
 
-  function setMaxSlippage(address yieldBearingAsset, uint96 newMaxSlippage) external;
+  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external;
 
   function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;
 }
diff --git a/tests/units/Rebalancer.t.sol b/tests/units/Rebalancer.t.sol
index 0754144..37e7963 100644
--- a/tests/units/Rebalancer.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -43,7 +43,7 @@ contract Test_Rebalancer_MaxSlippage is Fixture {
     vm.prank(guardian);
     rebalancer.setMaxSlippage(yieldBearingAsset, 1e7);
 
-    (,,,,, uint96 maxSlippage) = rebalancer.yieldBearingData(yieldBearingAsset);
+    (,,,,, uint64 maxSlippage) = rebalancer.yieldBearingData(yieldBearingAsset);
     assertEq(maxSlippage, 1e7);
   }
 

From b035be8bf10fbdb917e7739d99f04f1851914821 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 7 Sep 2026 22:19:11 +0300
Subject: [PATCH 17/38] fix(reward-handler): make the swap router configurable
 per chain

`sellRewards` forwarded its payload to `ODOS_ROUTER`, a constant holding the
Ethereum Odos address. The same facet bytecode ships to every chain, so the
target was wrong everywhere but mainnet. Checked on the five live deployments:

  mainnet     bytecode present, the Odos router
  sonic       bytecode present, an unrelated contract
  base        no bytecode
  avalanche   no bytecode
  hyperevm    no bytecode

A raw call to an address with no code returns success with empty returndata, so
the flow ran on to find no balance increase and reverted with InvalidSwap. The
selector is wired on all five diamonds.

The target moves to `swapRouter`, appended to `ParallelizerStorage` and set by
governance. Nothing is Odos specific: the payload is executed with a raw call, so
any aggregator or DEX can be configured. `ODOS_ROUTER` is gone, `OdosSwapFailed`
becomes `RewardSwapFailed`, and `MockOdosRouter` becomes `MockSwapRouter`.

An unset router now reverts instead of calling address zero, which would have
reported success and left the swap silently unperformed.

Layout.sol had drifted: it documented 9 slots while the struct had grown to 15
with the surplus distribution fields. It now mirrors all 16, and the layout test
asserts the tail so an append cannot slip through unnoticed again.

Governance must call `setSwapRouter` on every chain after the upgrade, before
rewards can be sold.

Bailsec Core Issue_15
---
 contracts/interfaces/IGetters.sol             |   3 +
 contracts/interfaces/IRewardHandler.sol       |   4 +-
 contracts/interfaces/ISetters.sol             |   5 +
 contracts/parallelizer/Layout.sol             |  11 +-
 contracts/parallelizer/Storage.sol            |   2 +
 contracts/parallelizer/facets/Getters.sol     |   5 +
 .../parallelizer/facets/RewardHandler.sol     |  10 +-
 .../parallelizer/facets/SettersGovernor.sol   |   5 +
 .../parallelizer/libraries/LibSetters.sol     |   8 ++
 contracts/utils/Constants.sol                 |  11 +-
 contracts/utils/Errors.sol                    |   2 +-
 generated/abis/BaseRebalancer.d.ts            |  12 +-
 generated/abis/BaseRebalancer.js              |  12 +-
 generated/abis/GenericRebalancer.d.ts         |  12 +-
 generated/abis/GenericRebalancer.js           |  12 +-
 generated/abis/Getters.d.ts                   |  13 +++
 generated/abis/Getters.js                     |  13 +++
 generated/abis/IGetters.d.ts                  |  13 +++
 generated/abis/IGetters.js                    |  13 +++
 generated/abis/IParallelizer.d.ts             |  26 +++++
 generated/abis/IParallelizer.js               |  26 +++++
 generated/abis/IRebalancer.d.ts               |   8 +-
 generated/abis/IRebalancer.js                 |   8 +-
 generated/abis/ISettersGovernor.d.ts          |  13 +++
 generated/abis/ISettersGovernor.js            |  13 +++
 generated/abis/Layout.d.ts                    | 109 ++++++++++++++++++
 generated/abis/Layout.js                      | 109 ++++++++++++++++++
 generated/abis/LibSetters.d.ts                |  13 +++
 generated/abis/LibSetters.js                  |  13 +++
 generated/abis/MultiBlockRebalancer.d.ts      |  12 +-
 generated/abis/MultiBlockRebalancer.js        |  12 +-
 generated/abis/RewardHandler.d.ts             |   9 +-
 generated/abis/RewardHandler.js               |   9 +-
 generated/abis/SettersGovernor.d.ts           |  31 +++++
 generated/abis/SettersGovernor.js             |  31 +++++
 scripts/SetParallelizerRoles.s.sol            |   3 +-
 ...{MockOdosRouter.sol => MockSwapRouter.sol} |   2 +-
 tests/units/Layout.t.sol                      |  26 ++++-
 tests/units/RewardHandlerTest.t.sol           | 102 ++++++++++------
 tests/utils/ConfigAccessManager.sol           |   3 +-
 40 files changed, 641 insertions(+), 103 deletions(-)
 rename tests/mock/{MockOdosRouter.sol => MockSwapRouter.sol} (97%)

diff --git a/contracts/interfaces/IGetters.sol b/contracts/interfaces/IGetters.sol
index 6f0d6e2..6e78de6 100644
--- a/contracts/interfaces/IGetters.sol
+++ b/contracts/interfaces/IGetters.sol
@@ -144,6 +144,9 @@ interface IGetters {
 
   /// @notice Returns the minimum collateral ratio that must hold after surplus processing
   /// @dev Expressed in base 1e9, and always >= 1e9
+  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to
+  function getSwapRouter() external view returns (address);
+
   function getSurplusBufferRatio() external view returns (uint64);
 
   /// @notice Computes the surplus of a collateral.
diff --git a/contracts/interfaces/IRewardHandler.sol b/contracts/interfaces/IRewardHandler.sol
index 742cd72..1ae085b 100644
--- a/contracts/interfaces/IRewardHandler.sol
+++ b/contracts/interfaces/IRewardHandler.sol
@@ -7,9 +7,9 @@ pragma solidity 0.8.28;
 /// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface
 /// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol
 interface IRewardHandler {
-  /// @notice Sells some external tokens through a odos call
+  /// @notice Sells some external tokens through a call to the configured swap router
   /// @param minAmountOut Minimum amount of the outToken to get
-  /// @param payload Payload to pass to odos
+  /// @param payload Payload to pass to the swap router
   /// @return amountOut Amount obtained of the outToken
   function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);
 }
diff --git a/contracts/interfaces/ISetters.sol b/contracts/interfaces/ISetters.sol
index 17b514b..d20111e 100644
--- a/contracts/interfaces/ISetters.sol
+++ b/contracts/interfaces/ISetters.sol
@@ -72,6 +72,11 @@ interface ISettersGovernor {
   /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing
   /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9
   function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;
+
+  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to
+  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain
+  /// specific and must be set on every deployment before rewards can be sold
+  function setSwapRouter(address swapRouter) external;
 }
 
 /// @title ISettersGovernor
diff --git a/contracts/parallelizer/Layout.sol b/contracts/parallelizer/Layout.sol
index 05dd496..6d2d640 100644
--- a/contracts/parallelizer/Layout.sol
+++ b/contracts/parallelizer/Layout.sol
@@ -36,8 +36,15 @@ contract Layout {
   mapping(address => uint256) public isTrusted; // slot 7
   mapping(address => uint256) public isSellerTrusted; // slot 8
   mapping(WhitelistType => mapping(address => uint256)) public isWhitelistedForType; // slot 9
-  // uint256(DIAMOND_STORAGE_POSITION) - ParallelizerStorage offset (9) - uint256(TRANSMUTER_STORAGE_POSITION)
-  uint256[56_904_584_862_873_869_173_946_452_133_933_512_717_281_559_375_467_474_726_875_187_792_230_718_146_205]
+  mapping(address => uint256) public slippageTolerance; // slot 10
+  uint64 public surplusBufferRatio; // slot 11
+  uint256 public lastReleasedAt; // slot 12
+  uint256 public totalShares; // slot 13
+  address[] public payees; // slot 14
+  mapping(address => uint256) public shares; // slot 15
+  address public swapRouter; // slot 16
+  // uint256(DIAMOND_STORAGE_POSITION) - ParallelizerStorage offset (16) - uint256(TRANSMUTER_STORAGE_POSITION)
+  uint256[56_904_584_862_873_869_173_946_452_133_933_512_717_281_559_375_467_474_726_875_187_792_230_718_146_198]
     private __gap3;
   bytes4[] public selectors; // slot 1
   mapping(bytes4 => FacetInfo) public selectorInfo; // slot 2
diff --git a/contracts/parallelizer/Storage.sol b/contracts/parallelizer/Storage.sol
index a77e16f..d735820 100644
--- a/contracts/parallelizer/Storage.sol
+++ b/contracts/parallelizer/Storage.sol
@@ -149,4 +149,6 @@ struct ParallelizerStorage {
   uint256 totalShares; // The total shares of the totalShares for all payees
   address[] payees; // The addresses of the payees
   mapping(address => uint256) shares; // The shares of the totalShares for each payee
+  // Aggregator or DEX the `RewardHandler` forwards its swap payload to
+  address swapRouter;
 }
diff --git a/contracts/parallelizer/facets/Getters.sol b/contracts/parallelizer/facets/Getters.sol
index e8e734f..bf58020 100644
--- a/contracts/parallelizer/facets/Getters.sol
+++ b/contracts/parallelizer/facets/Getters.sol
@@ -235,6 +235,11 @@ contract Getters is IGetters {
     return s.transmuterStorage().slippageTolerance[collateral];
   }
 
+  /// @inheritdoc IGetters
+  function getSwapRouter() external view returns (address) {
+    return s.transmuterStorage().swapRouter;
+  }
+
   /// @inheritdoc IGetters
   function getSurplusBufferRatio() external view returns (uint64) {
     return s.transmuterStorage().surplusBufferRatio;
diff --git a/contracts/parallelizer/facets/RewardHandler.sol b/contracts/parallelizer/facets/RewardHandler.sol
index 36892ac..2f8d063 100644
--- a/contracts/parallelizer/facets/RewardHandler.sol
+++ b/contracts/parallelizer/facets/RewardHandler.sol
@@ -30,7 +30,7 @@ contract RewardHandler is IRewardHandler, AccessManagedModifiers {
   /// @dev It is impossible to sell a token that is a collateral through this function
   /// @dev Trusted sellers and governance only may call this function
   /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval
-  /// transaction to Odos router for the token to be swapped
+  /// transaction to the configured `swapRouter` for the token to be swapped
   function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {
     ParallelizerStorage storage ts = s.transmuterStorage();
     if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();
@@ -44,8 +44,10 @@ contract RewardHandler is IRewardHandler, AccessManagedModifiers {
       balances[i] = IERC20(list[i]).balanceOf(address(this));
     }
     uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));
+    address swapRouter = ts.swapRouter;
+    if (swapRouter == address(0)) revert ZeroAddress();
     //solhint-disable-next-line
-    (bool success, bytes memory result) = ODOS_ROUTER.call(payload);
+    (bool success, bytes memory result) = swapRouter.call(payload);
     if (!success) _revertBytes(result);
     if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();
     bool hasIncreased;
@@ -70,7 +72,7 @@ contract RewardHandler is IRewardHandler, AccessManagedModifiers {
     }
   }
 
-  /// @notice Processes odos revert messages
+  /// @notice Processes the router's revert messages
   function _revertBytes(bytes memory errMsg) private pure {
     if (errMsg.length > 0) {
       //solhint-disable-next-line
@@ -78,6 +80,6 @@ contract RewardHandler is IRewardHandler, AccessManagedModifiers {
         revert(add(32, errMsg), mload(errMsg))
       }
     }
-    revert OdosSwapFailed();
+    revert RewardSwapFailed();
   }
 }
diff --git a/contracts/parallelizer/facets/SettersGovernor.sol b/contracts/parallelizer/facets/SettersGovernor.sol
index 8101664..1add36a 100644
--- a/contracts/parallelizer/facets/SettersGovernor.sol
+++ b/contracts/parallelizer/facets/SettersGovernor.sol
@@ -132,4 +132,9 @@ contract SettersGovernor is AccessManagedModifiers, ISettersGovernor {
   function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {
     LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);
   }
+
+  /// @inheritdoc ISettersGovernor
+  function setSwapRouter(address swapRouter) external restricted {
+    LibSetters.setSwapRouter(swapRouter);
+  }
 }
diff --git a/contracts/parallelizer/libraries/LibSetters.sol b/contracts/parallelizer/libraries/LibSetters.sol
index 7c72224..7de70b5 100644
--- a/contracts/parallelizer/libraries/LibSetters.sol
+++ b/contracts/parallelizer/libraries/LibSetters.sol
@@ -39,6 +39,7 @@ library LibSetters {
   event PayeeAdded(address indexed payee, uint256 shares);
   event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);
   event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);
+  event SwapRouterUpdated(address indexed swapRouter);
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     ONLY GOVERNOR ACTIONS
@@ -303,6 +304,13 @@ library LibSetters {
     emit SlippageToleranceUpdated(collateral, slippageTolerance);
   }
 
+  /// @notice Internal version of `setSwapRouter`
+  function setSwapRouter(address swapRouter) internal {
+    if (swapRouter == address(0)) revert ZeroAddress();
+    s.transmuterStorage().swapRouter = swapRouter;
+    emit SwapRouterUpdated(swapRouter);
+  }
+
   /// @notice Internal version of `updateSurplusBufferRatio`
   function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {
     if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();
diff --git a/contracts/utils/Constants.sol b/contracts/utils/Constants.sol
index 9ad8d55..da477a3 100644
--- a/contracts/utils/Constants.sol
+++ b/contracts/utils/Constants.sol
@@ -7,7 +7,7 @@ import { IStETH } from "contracts/interfaces/external/lido/IStETH.sol";
 import { IRETH } from "contracts/interfaces/external/rocketPool/IRETH.sol";
 
 /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                 STORAGE SLOTS                                                  
+                                                 STORAGE SLOTS
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
 /// @dev Storage position of `DiamondStorage` structure
@@ -23,7 +23,7 @@ bytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6
 bytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 
 /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                     MATHS                                                      
+                                                     MATHS
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
 uint256 constant BASE_6 = 1e6;
@@ -44,7 +44,7 @@ uint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;
 uint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;
 
 /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                     REENTRANT                                                      
+                                                     REENTRANT
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
 // The values being non-zero value makes deployment a bit more expensive,
@@ -56,7 +56,7 @@ uint8 constant NOT_ENTERED = 1;
 uint8 constant ENTERED = 2;
 
 /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                     REENTRANT                                                      
+                                                     REENTRANT
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
 // Role IDs for the AccessManager
@@ -65,11 +65,10 @@ uint64 constant GUARDIAN_ROLE = 20;
 uint64 constant KEEPER_ROLE = 30;
 
 /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                               COMMON ADDRESSES                                                 
+                                               COMMON ADDRESSES
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
 address constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
-address constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;
 ICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);
 IRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);
 IStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);
diff --git a/contracts/utils/Errors.sol b/contracts/utils/Errors.sol
index 35b7d99..6127e29 100644
--- a/contracts/utils/Errors.sol
+++ b/contracts/utils/Errors.sol
@@ -40,7 +40,7 @@ error NotGuardian();
 error NotTrusted();
 error NotTrustedOrGuardian();
 error NotWhitelisted();
-error OdosSwapFailed();
+error RewardSwapFailed();
 error OracleUpdateFailed();
 error SurplusBufferRatioNotSet();
 error Paused();
diff --git a/generated/abis/BaseRebalancer.d.ts b/generated/abis/BaseRebalancer.d.ts
index c0b1549..e4b84cf 100644
--- a/generated/abis/BaseRebalancer.d.ts
+++ b/generated/abis/BaseRebalancer.d.ts
@@ -301,9 +301,9 @@ export type Abi_BaseRebalancer = [
         "type": "address"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "newMaxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setMaxSlippage",
@@ -362,9 +362,9 @@ export type Abi_BaseRebalancer = [
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setYieldBearingAssetData",
@@ -447,9 +447,9 @@ export type Abi_BaseRebalancer = [
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "stateMutability": "view",
diff --git a/generated/abis/BaseRebalancer.js b/generated/abis/BaseRebalancer.js
index 01d033e..ae7124b 100644
--- a/generated/abis/BaseRebalancer.js
+++ b/generated/abis/BaseRebalancer.js
@@ -301,9 +301,9 @@ export const Abi_BaseRebalancer = /** @type {const} **/ ([
         "type": "address"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "newMaxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setMaxSlippage",
@@ -362,9 +362,9 @@ export const Abi_BaseRebalancer = /** @type {const} **/ ([
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setYieldBearingAssetData",
@@ -447,9 +447,9 @@ export const Abi_BaseRebalancer = /** @type {const} **/ ([
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "stateMutability": "view",
diff --git a/generated/abis/GenericRebalancer.d.ts b/generated/abis/GenericRebalancer.d.ts
index 02676fa..2631a39 100644
--- a/generated/abis/GenericRebalancer.d.ts
+++ b/generated/abis/GenericRebalancer.d.ts
@@ -503,9 +503,9 @@ export type Abi_GenericRebalancer = [
         "type": "address"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "newMaxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setMaxSlippage",
@@ -590,9 +590,9 @@ export type Abi_GenericRebalancer = [
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setYieldBearingAssetData",
@@ -701,9 +701,9 @@ export type Abi_GenericRebalancer = [
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "stateMutability": "view",
diff --git a/generated/abis/GenericRebalancer.js b/generated/abis/GenericRebalancer.js
index 816a64c..618e224 100644
--- a/generated/abis/GenericRebalancer.js
+++ b/generated/abis/GenericRebalancer.js
@@ -503,9 +503,9 @@ export const Abi_GenericRebalancer = /** @type {const} **/ ([
         "type": "address"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "newMaxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setMaxSlippage",
@@ -590,9 +590,9 @@ export const Abi_GenericRebalancer = /** @type {const} **/ ([
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setYieldBearingAssetData",
@@ -701,9 +701,9 @@ export const Abi_GenericRebalancer = /** @type {const} **/ ([
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "stateMutability": "view",
diff --git a/generated/abis/Getters.d.ts b/generated/abis/Getters.d.ts
index 5b672f5..3017b70 100644
--- a/generated/abis/Getters.d.ts
+++ b/generated/abis/Getters.d.ts
@@ -547,6 +547,19 @@ export type Abi_Getters = [
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "getSwapRouter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "getTotalIssued",
diff --git a/generated/abis/Getters.js b/generated/abis/Getters.js
index c9ab986..c354e77 100644
--- a/generated/abis/Getters.js
+++ b/generated/abis/Getters.js
@@ -547,6 +547,19 @@ export const Abi_Getters = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "getSwapRouter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "getTotalIssued",
diff --git a/generated/abis/IGetters.d.ts b/generated/abis/IGetters.d.ts
index c80683b..f8d2479 100644
--- a/generated/abis/IGetters.d.ts
+++ b/generated/abis/IGetters.d.ts
@@ -506,6 +506,19 @@ export type Abi_IGetters = [
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "getSwapRouter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "getTotalIssued",
diff --git a/generated/abis/IGetters.js b/generated/abis/IGetters.js
index 3ea36b6..d816162 100644
--- a/generated/abis/IGetters.js
+++ b/generated/abis/IGetters.js
@@ -506,6 +506,19 @@ export const Abi_IGetters = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "getSwapRouter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "getTotalIssued",
diff --git a/generated/abis/IParallelizer.d.ts b/generated/abis/IParallelizer.d.ts
index 40cf117..fc55b22 100644
--- a/generated/abis/IParallelizer.d.ts
+++ b/generated/abis/IParallelizer.d.ts
@@ -681,6 +681,19 @@ export type Abi_IParallelizer = [
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "getSwapRouter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "getTotalIssued",
@@ -1393,6 +1406,19 @@ export type Abi_IParallelizer = [
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "setSwapRouter",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/IParallelizer.js b/generated/abis/IParallelizer.js
index c95621f..fc8f2ef 100644
--- a/generated/abis/IParallelizer.js
+++ b/generated/abis/IParallelizer.js
@@ -681,6 +681,19 @@ export const Abi_IParallelizer = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "getSwapRouter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "getTotalIssued",
@@ -1393,6 +1406,19 @@ export const Abi_IParallelizer = /** @type {const} **/ ([
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "setSwapRouter",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/IRebalancer.d.ts b/generated/abis/IRebalancer.d.ts
index 71bebfc..f465af5 100644
--- a/generated/abis/IRebalancer.d.ts
+++ b/generated/abis/IRebalancer.d.ts
@@ -30,9 +30,9 @@ export type Abi_IRebalancer = [
         "type": "address"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "newMaxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setMaxSlippage",
@@ -73,9 +73,9 @@ export type Abi_IRebalancer = [
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setYieldBearingAssetData",
diff --git a/generated/abis/IRebalancer.js b/generated/abis/IRebalancer.js
index f69a3a1..3f56760 100644
--- a/generated/abis/IRebalancer.js
+++ b/generated/abis/IRebalancer.js
@@ -30,9 +30,9 @@ export const Abi_IRebalancer = /** @type {const} **/ ([
         "type": "address"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "newMaxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setMaxSlippage",
@@ -73,9 +73,9 @@ export const Abi_IRebalancer = /** @type {const} **/ ([
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setYieldBearingAssetData",
diff --git a/generated/abis/ISettersGovernor.d.ts b/generated/abis/ISettersGovernor.d.ts
index afe2a07..bb0a501 100644
--- a/generated/abis/ISettersGovernor.d.ts
+++ b/generated/abis/ISettersGovernor.d.ts
@@ -170,6 +170,19 @@ export type Abi_ISettersGovernor = [
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "setSwapRouter",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/ISettersGovernor.js b/generated/abis/ISettersGovernor.js
index 8f7c6b2..fe08435 100644
--- a/generated/abis/ISettersGovernor.js
+++ b/generated/abis/ISettersGovernor.js
@@ -170,6 +170,19 @@ export const Abi_ISettersGovernor = /** @type {const} **/ ([
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "setSwapRouter",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/Layout.d.ts b/generated/abis/Layout.d.ts
index aef94a5..6c98465 100644
--- a/generated/abis/Layout.d.ts
+++ b/generated/abis/Layout.d.ts
@@ -208,6 +208,19 @@ export type Abi_Layout = [
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "lastReleasedAt",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "nonReentrant",
@@ -247,6 +260,25 @@ export type Abi_Layout = [
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "name": "payees",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {
@@ -290,6 +322,70 @@ export type Abi_Layout = [
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "shares",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "slippageTolerance",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "surplusBufferRatio",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "swapRouter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "tokenP",
@@ -303,6 +399,19 @@ export type Abi_Layout = [
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "totalShares",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/Layout.js b/generated/abis/Layout.js
index 3baba84..143e2fc 100644
--- a/generated/abis/Layout.js
+++ b/generated/abis/Layout.js
@@ -208,6 +208,19 @@ export const Abi_Layout = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "lastReleasedAt",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "nonReentrant",
@@ -247,6 +260,25 @@ export const Abi_Layout = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "name": "payees",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {
@@ -290,6 +322,70 @@ export const Abi_Layout = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "shares",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "slippageTolerance",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "surplusBufferRatio",
+    "outputs": [
+      {
+        "internalType": "uint64",
+        "name": "",
+        "type": "uint64"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "swapRouter",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [],
     "name": "tokenP",
@@ -303,6 +399,19 @@ export const Abi_Layout = /** @type {const} **/ ([
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [],
+    "name": "totalShares",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/LibSetters.d.ts b/generated/abis/LibSetters.d.ts
index 96f2fd7..74c1586 100644
--- a/generated/abis/LibSetters.d.ts
+++ b/generated/abis/LibSetters.d.ts
@@ -289,6 +289,19 @@ export type Abi_LibSetters = [
     "name": "SurplusBufferRatioUpdated",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "SwapRouterUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
diff --git a/generated/abis/LibSetters.js b/generated/abis/LibSetters.js
index 28025fe..e3e8446 100644
--- a/generated/abis/LibSetters.js
+++ b/generated/abis/LibSetters.js
@@ -289,6 +289,19 @@ export const Abi_LibSetters = /** @type {const} **/ ([
     "name": "SurplusBufferRatioUpdated",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "SwapRouterUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
diff --git a/generated/abis/MultiBlockRebalancer.d.ts b/generated/abis/MultiBlockRebalancer.d.ts
index 18e1fcb..0eb6141 100644
--- a/generated/abis/MultiBlockRebalancer.d.ts
+++ b/generated/abis/MultiBlockRebalancer.d.ts
@@ -355,9 +355,9 @@ export type Abi_MultiBlockRebalancer = [
         "type": "address"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "newMaxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setMaxSlippage",
@@ -416,9 +416,9 @@ export type Abi_MultiBlockRebalancer = [
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setYieldBearingAssetData",
@@ -519,9 +519,9 @@ export type Abi_MultiBlockRebalancer = [
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "stateMutability": "view",
diff --git a/generated/abis/MultiBlockRebalancer.js b/generated/abis/MultiBlockRebalancer.js
index 523e7b2..b999476 100644
--- a/generated/abis/MultiBlockRebalancer.js
+++ b/generated/abis/MultiBlockRebalancer.js
@@ -355,9 +355,9 @@ export const Abi_MultiBlockRebalancer = /** @type {const} **/ ([
         "type": "address"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "newMaxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setMaxSlippage",
@@ -416,9 +416,9 @@ export const Abi_MultiBlockRebalancer = /** @type {const} **/ ([
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "name": "setYieldBearingAssetData",
@@ -519,9 +519,9 @@ export const Abi_MultiBlockRebalancer = /** @type {const} **/ ([
         "type": "uint64"
       },
       {
-        "internalType": "uint96",
+        "internalType": "uint64",
         "name": "maxSlippage",
-        "type": "uint96"
+        "type": "uint64"
       }
     ],
     "stateMutability": "view",
diff --git a/generated/abis/RewardHandler.d.ts b/generated/abis/RewardHandler.d.ts
index 8aa4d3a..14b0fdc 100644
--- a/generated/abis/RewardHandler.d.ts
+++ b/generated/abis/RewardHandler.d.ts
@@ -16,12 +16,12 @@ export type Abi_RewardHandler = [
   },
   {
     "inputs": [],
-    "name": "OdosSwapFailed",
+    "name": "ReentrantCall",
     "type": "error"
   },
   {
     "inputs": [],
-    "name": "ReentrantCall",
+    "name": "RewardSwapFailed",
     "type": "error"
   },
   {
@@ -40,6 +40,11 @@ export type Abi_RewardHandler = [
     "name": "TooSmallAmountOut",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "ZeroAddress",
+    "type": "error"
+  },
   {
     "anonymous": false,
     "inputs": [
diff --git a/generated/abis/RewardHandler.js b/generated/abis/RewardHandler.js
index b5a1e24..2ddf666 100644
--- a/generated/abis/RewardHandler.js
+++ b/generated/abis/RewardHandler.js
@@ -16,12 +16,12 @@ export const Abi_RewardHandler = /** @type {const} **/ ([
   },
   {
     "inputs": [],
-    "name": "OdosSwapFailed",
+    "name": "ReentrantCall",
     "type": "error"
   },
   {
     "inputs": [],
-    "name": "ReentrantCall",
+    "name": "RewardSwapFailed",
     "type": "error"
   },
   {
@@ -40,6 +40,11 @@ export const Abi_RewardHandler = /** @type {const} **/ ([
     "name": "TooSmallAmountOut",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "ZeroAddress",
+    "type": "error"
+  },
   {
     "anonymous": false,
     "inputs": [
diff --git a/generated/abis/SettersGovernor.d.ts b/generated/abis/SettersGovernor.d.ts
index 7b99c32..2f0ba6e 100644
--- a/generated/abis/SettersGovernor.d.ts
+++ b/generated/abis/SettersGovernor.d.ts
@@ -133,6 +133,11 @@ export type Abi_SettersGovernor = [
     "name": "SafeERC20FailedOperation",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "ZeroAddress",
+    "type": "error"
+  },
   {
     "inputs": [],
     "name": "ZeroAmount",
@@ -428,6 +433,19 @@ export type Abi_SettersGovernor = [
     "name": "SurplusBufferRatioUpdated",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "SwapRouterUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -624,6 +642,19 @@ export type Abi_SettersGovernor = [
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "setSwapRouter",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/generated/abis/SettersGovernor.js b/generated/abis/SettersGovernor.js
index b09aaa5..50359af 100644
--- a/generated/abis/SettersGovernor.js
+++ b/generated/abis/SettersGovernor.js
@@ -133,6 +133,11 @@ export const Abi_SettersGovernor = /** @type {const} **/ ([
     "name": "SafeERC20FailedOperation",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "ZeroAddress",
+    "type": "error"
+  },
   {
     "inputs": [],
     "name": "ZeroAmount",
@@ -428,6 +433,19 @@ export const Abi_SettersGovernor = /** @type {const} **/ ([
     "name": "SurplusBufferRatioUpdated",
     "type": "event"
   },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "SwapRouterUpdated",
+    "type": "event"
+  },
   {
     "anonymous": false,
     "inputs": [
@@ -624,6 +642,19 @@ export const Abi_SettersGovernor = /** @type {const} **/ ([
     "stateMutability": "nonpayable",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "swapRouter",
+        "type": "address"
+      }
+    ],
+    "name": "setSwapRouter",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
   {
     "inputs": [
       {
diff --git a/scripts/SetParallelizerRoles.s.sol b/scripts/SetParallelizerRoles.s.sol
index 8762e67..ea01ede 100644
--- a/scripts/SetParallelizerRoles.s.sol
+++ b/scripts/SetParallelizerRoles.s.sol
@@ -21,7 +21,7 @@ contract SetParallelizerRoles is BaseScript {
     guardianSelectors[6] = IDiamondEtherscan.setDummyImplementation.selector;
     accessManager.setTargetFunctionRole(parallelizer, guardianSelectors, Roles.GUARDIAN_ROLE);
 
-    bytes4[] memory governorSelectors = new bytes4[](14);
+    bytes4[] memory governorSelectors = new bytes4[](15);
     governorSelectors[0] = ISettersGovernor.recoverERC20.selector;
     governorSelectors[1] = ISettersGovernor.setAccessManager.selector;
     governorSelectors[2] = ISettersGovernor.setCollateralManager.selector;
@@ -36,6 +36,7 @@ contract SetParallelizerRoles is BaseScript {
     governorSelectors[11] = ISettersGovernor.updatePayees.selector;
     governorSelectors[12] = ISettersGovernor.updateSlippageTolerance.selector;
     governorSelectors[13] = ISettersGovernor.updateSurplusBufferRatio.selector;
+    governorSelectors[14] = ISettersGovernor.setSwapRouter.selector;
     accessManager.setTargetFunctionRole(parallelizer, governorSelectors, Roles.GOVERNOR_ROLE);
 
     bytes4[] memory keeperSelectors = new bytes4[](2);
diff --git a/tests/mock/MockOdosRouter.sol b/tests/mock/MockSwapRouter.sol
similarity index 97%
rename from tests/mock/MockOdosRouter.sol
rename to tests/mock/MockSwapRouter.sol
index f71e78e..2118141 100644
--- a/tests/mock/MockOdosRouter.sol
+++ b/tests/mock/MockSwapRouter.sol
@@ -7,7 +7,7 @@ import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import "../../contracts/utils/Constants.sol";
 import "../../contracts/utils/Errors.sol";
 
-contract MockOdosRouter {
+contract MockSwapRouter {
   using SafeERC20 for IERC20;
 
   bool public setRevert;
diff --git a/tests/units/Layout.t.sol b/tests/units/Layout.t.sol
index decfdc4..d61828d 100644
--- a/tests/units/Layout.t.sol
+++ b/tests/units/Layout.t.sol
@@ -24,6 +24,20 @@ contract Test_Layout is Fixture {
     layout = Layout(address(parallelizer));
   }
 
+  /// @dev Read before `_etch()` replaces the diamond's code, kept in storage so `test_Layout`
+  /// stays within the EVM stack-depth limit
+  uint64 internal _surplusBufferRatio;
+  uint256 internal _lastReleasedAt;
+  uint256 internal _totalShares;
+
+  /// @dev The tail of `ParallelizerStorage`, added after the initial layout was written down
+  function _assertStructTail() internal view {
+    assertEq(layout.surplusBufferRatio(), _surplusBufferRatio);
+    assertEq(layout.lastReleasedAt(), _lastReleasedAt);
+    assertEq(layout.totalShares(), _totalShares);
+    assertEq(layout.swapRouter(), address(bob));
+  }
+
   function test_Layout() public {
     address tokenP = address(parallelizer.tokenP());
     uint8 isRedemptionLive = parallelizer.isPaused(address(0), ActionType.Redeem) ? 0 : 1;
@@ -36,6 +50,11 @@ contract Test_Layout is Fixture {
     hoax(governor);
     parallelizer.toggleTrusted(alice, TrustedType.Seller);
     address accessManager = parallelizer.accessManager();
+    hoax(governor);
+    parallelizer.setSwapRouter(address(bob));
+    _surplusBufferRatio = parallelizer.getSurplusBufferRatio();
+    _lastReleasedAt = parallelizer.getLastReleasedAt();
+    _totalShares = parallelizer.getTotalShares();
     hoax(guardian);
     parallelizer.setDummyImplementation(address(alice));
     address implementation = parallelizer.implementation();
@@ -62,8 +81,7 @@ contract Test_Layout is Fixture {
       uint8 onlyWhitelisted,
       uint216 normalizedStables,
       bytes memory oracleConfig,
-      bytes memory whitelistData,
-      ,
+      bytes memory whitelistData,,
     ) = layout.collaterals(collateralList[0]);
 
     assertEq(isManaged, collateral.isManaged);
@@ -86,12 +104,14 @@ contract Test_Layout is Fixture {
       assertEq(layout.selectors(selectorPosition), selectors[i]);
     }
 
+    _assertStructTail();
+
     assertEq(layout.accessManager(), accessManager);
     assertEq(layout.implementation(), implementation);
   }
 
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    INTERNAL                                                     
+    INTERNAL
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
   function _etch() internal {
diff --git a/tests/units/RewardHandlerTest.t.sol b/tests/units/RewardHandlerTest.t.sol
index 03558cc..33276d5 100644
--- a/tests/units/RewardHandlerTest.t.sol
+++ b/tests/units/RewardHandlerTest.t.sol
@@ -6,7 +6,7 @@ import { IERC20 } from "@openzeppelin/contracts/interfaces/IERC20.sol";
 
 import { stdError } from "@forge-std/Test.sol";
 
-import { MockOdosRouter } from "tests/mock/MockOdosRouter.sol";
+import { MockSwapRouter } from "tests/mock/MockSwapRouter.sol";
 import { MockTokenPermit } from "tests/mock/MockTokenPermit.sol";
 
 import "contracts/parallelizer/Storage.sol";
@@ -17,19 +17,18 @@ import "../Fixture.sol";
 contract RewardHandlerTest is Fixture {
   event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);
 
-  MockOdosRouter odos;
+  MockSwapRouter router;
   IERC20 tokenA;
   IERC20 tokenB;
 
   function setUp() public override {
     super.setUp();
-    odos = MockOdosRouter(ODOS_ROUTER);
-
     tokenA = IERC20(address(new MockTokenPermit("tokenA", "tokenA", 18)));
     tokenB = IERC20(address(new MockTokenPermit("tokenA", "tokenA", 9)));
 
-    MockOdosRouter tempRouter = new MockOdosRouter();
-    vm.etch(address(odos), address(tempRouter).code);
+    router = new MockSwapRouter();
+    hoax(governor);
+    parallelizer.setSwapRouter(address(router));
   }
 
   function test_RevertWhen_SellRewards_NotTrusted() public {
@@ -42,7 +41,7 @@ contract RewardHandlerTest is Fixture {
   function test_RevertWhen_SellRewards_NoApproval() public {
     vm.startPrank(guardian);
     bytes memory payload =
-      abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(tokenA), address(tokenB));
+      abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(tokenA), address(tokenB));
     vm.expectRevert();
     parallelizer.sellRewards(0, payload);
     vm.stopPrank();
@@ -50,12 +49,12 @@ contract RewardHandlerTest is Fixture {
 
   function test_RevertWhen_SellRewards_NoIncrease() public {
     bytes memory payload =
-      abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(tokenA), address(tokenB));
+      abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(tokenA), address(tokenB));
     vm.startPrank(governor);
 
     deal(address(tokenA), address(parallelizer), 100);
-    deal(address(tokenB), address(odos), 100);
-    parallelizer.changeAllowance(tokenA, address(odos), 100);
+    deal(address(tokenB), address(router), 100);
+    parallelizer.changeAllowance(tokenA, address(router), 100);
     vm.expectRevert(Errors.InvalidSwap.selector);
     parallelizer.sellRewards(0, payload);
     vm.stopPrank();
@@ -63,12 +62,12 @@ contract RewardHandlerTest is Fixture {
 
   function test_RevertWhen_SellRewards_TooSmallAmountOut() public {
     bytes memory payload =
-      abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(tokenA), address(eurA));
+      abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(tokenA), address(eurA));
     vm.startPrank(governor);
 
     deal(address(tokenA), address(parallelizer), 100);
-    deal(address(eurA), address(odos), 100);
-    parallelizer.changeAllowance(tokenA, address(odos), 100);
+    deal(address(eurA), address(router), 100);
+    parallelizer.changeAllowance(tokenA, address(router), 100);
     vm.expectRevert(Errors.TooSmallAmountOut.selector);
     parallelizer.sellRewards(1000, payload);
     vm.stopPrank();
@@ -76,39 +75,39 @@ contract RewardHandlerTest is Fixture {
 
   function test_RevertWhen_SellRewards_EmptyErrorMessage() public {
     bytes memory payload =
-      abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(tokenA), address(tokenB));
+      abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(tokenA), address(tokenB));
     vm.startPrank(governor);
 
     deal(address(tokenA), address(parallelizer), 100);
-    deal(address(tokenB), address(odos), 100);
-    parallelizer.changeAllowance(tokenA, address(odos), 100);
-    odos.setRevertStatuses(true, false);
-    vm.expectRevert(Errors.OdosSwapFailed.selector);
+    deal(address(tokenB), address(router), 100);
+    parallelizer.changeAllowance(tokenA, address(router), 100);
+    router.setRevertStatuses(true, false);
+    vm.expectRevert(Errors.RewardSwapFailed.selector);
     parallelizer.sellRewards(0, payload);
     vm.stopPrank();
   }
 
   function test_RevertWhen_SellRewards_ErrorMessage() public {
     bytes memory payload =
-      abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(tokenA), address(tokenB));
+      abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(tokenA), address(tokenB));
     vm.startPrank(governor);
 
     deal(address(tokenA), address(parallelizer), 100);
-    deal(address(tokenB), address(odos), 100);
-    parallelizer.changeAllowance(tokenA, address(odos), 100);
-    odos.setRevertStatuses(false, true);
+    deal(address(tokenB), address(router), 100);
+    parallelizer.changeAllowance(tokenA, address(router), 100);
+    router.setRevertStatuses(false, true);
     vm.expectRevert("wrong swap");
     parallelizer.sellRewards(0, payload);
     vm.stopPrank();
   }
 
   function test_RevertWhen_SellRewards_InvalidSwapBecauseTokenSold() public {
-    bytes memory payload = abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(eurA), address(eurB));
+    bytes memory payload = abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(eurA), address(eurB));
     vm.startPrank(governor);
 
     deal(address(eurA), address(parallelizer), 100);
-    deal(address(eurB), address(odos), 100);
-    parallelizer.changeAllowance(eurA, address(odos), 100);
+    deal(address(eurB), address(router), 100);
+    parallelizer.changeAllowance(eurA, address(router), 100);
     vm.expectRevert(Errors.InvalidSwap.selector);
     parallelizer.sellRewards(0, payload);
     vm.stopPrank();
@@ -116,12 +115,12 @@ contract RewardHandlerTest is Fixture {
 
   function test_SellRewards_WithOneTokenIncrease() public {
     bytes memory payload =
-      abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(tokenA), address(eurA));
+      abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(tokenA), address(eurA));
     vm.startPrank(governor);
 
     deal(address(tokenA), address(parallelizer), 100);
-    deal(address(eurA), address(odos), 100);
-    parallelizer.changeAllowance(tokenA, address(odos), 100);
+    deal(address(eurA), address(router), 100);
+    parallelizer.changeAllowance(tokenA, address(router), 100);
     vm.expectEmit(address(parallelizer));
     emit RewardsSoldFor(address(eurA), 100);
     parallelizer.sellRewards(0, payload);
@@ -130,12 +129,12 @@ contract RewardHandlerTest is Fixture {
 
   function test_RevertWhen_SellRewards_TokenPSold() public {
     bytes memory payload =
-      abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(tokenP), address(eurA));
+      abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(tokenP), address(eurA));
     vm.startPrank(governor);
 
     deal(address(tokenP), address(parallelizer), 100);
-    deal(address(eurA), address(odos), 100);
-    parallelizer.changeAllowance(IERC20(address(tokenP)), address(odos), 100);
+    deal(address(eurA), address(router), 100);
+    parallelizer.changeAllowance(IERC20(address(tokenP)), address(router), 100);
     vm.expectRevert(Errors.InvalidTokens.selector);
     parallelizer.sellRewards(0, payload);
     vm.stopPrank();
@@ -143,14 +142,14 @@ contract RewardHandlerTest is Fixture {
 
   function test_SellRewards_WithOneTokenIncreaseAndTrusted() public {
     bytes memory payload =
-      abi.encodeWithSelector(MockOdosRouter.swap.selector, 100, 100, address(tokenA), address(eurA));
+      abi.encodeWithSelector(MockSwapRouter.swap.selector, 100, 100, address(tokenA), address(eurA));
     vm.startPrank(governor);
     parallelizer.toggleTrusted(alice, TrustedType.Seller);
-    parallelizer.changeAllowance(tokenA, address(odos), 100);
+    parallelizer.changeAllowance(tokenA, address(router), 100);
     vm.stopPrank();
 
     deal(address(tokenA), address(parallelizer), 100);
-    deal(address(eurA), address(odos), 100);
+    deal(address(eurA), address(router), 100);
 
     vm.expectEmit(address(parallelizer));
     emit RewardsSoldFor(address(eurA), 100);
@@ -158,3 +157,38 @@ contract RewardHandlerTest is Fixture {
     parallelizer.sellRewards(0, payload);
   }
 }
+
+contract Test_SwapRouter is Fixture {
+  event SwapRouterUpdated(address indexed swapRouter);
+
+  function test_SetSwapRouter_UpdatesTheLiveRouter() public {
+    assertEq(parallelizer.getSwapRouter(), address(0), "no router before governance sets one");
+
+    vm.expectEmit(address(parallelizer));
+    emit SwapRouterUpdated(bob);
+    hoax(governor);
+    parallelizer.setSwapRouter(bob);
+
+    assertEq(parallelizer.getSwapRouter(), bob);
+  }
+
+  function test_RevertWhen_SetSwapRouterIsZero() public {
+    hoax(governor);
+    vm.expectRevert(Errors.ZeroAddress.selector);
+    parallelizer.setSwapRouter(address(0));
+  }
+
+  function test_RevertWhen_SetSwapRouterNotGovernor() public {
+    hoax(guardian);
+    vm.expectRevert(abi.encodeWithSelector(Errors.AccessManagedUnauthorized.selector, guardian));
+    parallelizer.setSwapRouter(bob);
+  }
+
+  /// @dev A raw call to address zero would report success and leave the swap silently unperformed
+  function test_RevertWhen_SellRewardsBeforeARouterIsSet() public {
+    bytes memory payload;
+    hoax(governor);
+    vm.expectRevert(Errors.ZeroAddress.selector);
+    parallelizer.sellRewards(0, payload);
+  }
+}
diff --git a/tests/utils/ConfigAccessManager.sol b/tests/utils/ConfigAccessManager.sol
index 3fa285e..8359831 100644
--- a/tests/utils/ConfigAccessManager.sol
+++ b/tests/utils/ConfigAccessManager.sol
@@ -99,7 +99,7 @@ abstract contract ConfigAccessManager is Helper {
   }
 
   function getParallelizerGovernorSelectorAccess() internal pure returns (bytes4[] memory) {
-    bytes4[] memory selectors = new bytes4[](14);
+    bytes4[] memory selectors = new bytes4[](15);
     selectors[0] = SettersGovernor.recoverERC20.selector;
     selectors[1] = SettersGovernor.setAccessManager.selector;
     selectors[2] = SettersGovernor.setCollateralManager.selector;
@@ -114,6 +114,7 @@ abstract contract ConfigAccessManager is Helper {
     selectors[11] = SettersGovernor.updatePayees.selector;
     selectors[12] = SettersGovernor.updateSlippageTolerance.selector;
     selectors[13] = SettersGovernor.updateSurplusBufferRatio.selector;
+    selectors[14] = SettersGovernor.setSwapRouter.selector;
     return selectors;
   }
 

From bf2508607c58b6f1e1faffb66b8fa8237d421587 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 8 Sep 2026 10:31:13 +0300
Subject: [PATCH 18/38] test(redeemer): measure the donation attack and what
 actually starves it

Bailsec Core Issue_10 records the remediation as smoothing the redemption curve
to prevent profitability. The curve live on all five chains is indeed shallow:

  collateral ratio  75%    85%    95%    97%
  payout factor     99.5%  95%    95%    99.5%

A 4.5 point band, against the 40 point swing the finding illustrates. It raises
the bar without closing it. Against those exact parameters, with a second holder
present so the transfer is visible and a correctly priced donation asset:

  attacker share    25%     30%     35%     40%     50%
  net result       -444    -133    +178    +489   +1111

Break-even sits between 30% and 35% of supply. At 50% the attacker gains 1111
while the other holder loses 1106, so it is a transfer, not an artefact. No
overvalued collateral is needed, unlike the finding's illustration.

What decides profitability is not that a deterrent exists but how steeply it
climbs back. The attacker pays in ratio points and is repaid in payout points on
their own redemption, recovering the share `f` they still hold a claim on, so a
ramp starves the attack when its slope stays below (1 - f) / (f * H/S). Holding
the same 4.5 point deterrent and widening the band:

  slope            0.900   0.450   0.225   0.112
  attacker at 50%   loses   loses   loses   loses
  attacker at 90%   GAINS   GAINS   GAINS   loses

Measured thresholds match the formula: about 1.05 against half the supply, about
0.12 against ninety percent. The deployed curve sits at 2.25.

So the deterrent does not have to be given up. Ramping the same 4.5 points from a
60% ratio up to 100% lands at slope 0.112 and starves the attack even against a
holder of ninety percent of the supply, while removing the current shape's oddity
of paying its best rate at the deepest undercollateralization.

Flattening also works, and `y[last]` prices every redemption above a 100% ratio,
so it has to flatten at 99.5%: flattening at 95% would cost healthy redeemers
4.52% instead of 0.5%.

Bounds are asserted rather than only printed, so changing the curve fails these
tests and forces the trade-off to be re-measured.
---
 .../units/DonationRedemptionCoefficient.t.sol | 324 ++++++++++++++++++
 1 file changed, 324 insertions(+)
 create mode 100644 tests/units/DonationRedemptionCoefficient.t.sol

diff --git a/tests/units/DonationRedemptionCoefficient.t.sol b/tests/units/DonationRedemptionCoefficient.t.sol
new file mode 100644
index 0000000..7a8082d
--- /dev/null
+++ b/tests/units/DonationRedemptionCoefficient.t.sol
@@ -0,0 +1,324 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity 0.8.28;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { IERC20Metadata } from "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
+import { console } from "@forge-std/console.sol";
+
+import { MockChainlinkOracle } from "../mock/MockChainlinkOracle.sol";
+import { Fixture } from "../Fixture.sol";
+import "contracts/utils/Constants.sol";
+
+/// @notice Bailsec Core Issue_10. A donation lifts the reported collateral ratio without lifting
+/// tracked issuance, so it can buy a better redemption coefficient. Measured against the redemption
+/// curve live on all five chains, with a second holder present so the transfer of value is visible.
+contract Test_DonationRedemptionCoefficient is Fixture {
+  /// @dev The curve deployed on mainnet, sonic, base, avalanche and hyperevm
+  function _setLiveRedemptionCurve() internal {
+    uint64[] memory x = new uint64[](4);
+    x[0] = 750_000_000;
+    x[1] = 850_000_000;
+    x[2] = 950_000_000;
+    x[3] = 970_000_000;
+    int64[] memory y = new int64[](4);
+    y[0] = 995_000_000;
+    y[1] = 950_000_000;
+    y[2] = 950_000_000;
+    y[3] = 995_000_000;
+    hoax(guardian);
+    parallelizer.setRedemptionCurveParams(x, y);
+  }
+
+  function setUp() public override {
+    super.setUp();
+    _setLiveRedemptionCurve();
+    // alice attacks, bob is the holder she would be extracting from. Splitting the position by
+    // transfer rather than a second mint keeps the exposure fee curve out of the measurement
+    _mintExactInput(alice, address(eurA), 100_000 * BASE_6, 0);
+    _setRatioTo(950_000_000);
+  }
+
+  /// @dev Calibrates the eurA oracle so the reported ratio lands on `target`, rather than assuming
+  /// what the fixture's mints issued
+  function _setRatioTo(uint64 target) internal {
+    uint256 issued = parallelizer.getTotalIssued();
+    uint256 balance = IERC20(address(eurA)).balanceOf(address(parallelizer));
+    uint8 dec = IERC20Metadata(address(eurA)).decimals();
+    // answer is 8 decimals, balance carries `dec`, issued and target are 18 and 9 decimals
+    uint256 answer = (uint256(target) * issued * (10 ** dec) * BASE_8) / (BASE_9 * balance * BASE_18);
+    MockChainlinkOracle(address(oracleA)).setLatestAnswer(int256(answer));
+  }
+
+  function _valueOf(address token, uint256 amount) internal view returns (uint256) {
+    (,,,, uint256 oracleValue) = parallelizer.getOracleValues(token);
+    return (oracleValue * amount) / (10 ** IERC20Metadata(token).decimals());
+  }
+
+  /// @dev Oracle value of the collateral `who` holds outside the Parallelizer
+  function _walletValue(address who) internal view returns (uint256 total) {
+    address[] memory list = parallelizer.getCollateralList();
+    for (uint256 i; i < list.length; ++i) {
+      total += _valueOf(list[i], IERC20(list[i]).balanceOf(who));
+    }
+  }
+
+  /// @dev Oracle value `who` would get by redeeming everything they still hold
+  function _claimValue(address who) internal view returns (uint256 total) {
+    uint256 bal = tokenP.balanceOf(who);
+    if (bal == 0) return 0;
+    // the quote refuses to price the entire remaining issuance
+    if (bal >= parallelizer.getTotalIssued()) bal = parallelizer.getTotalIssued() - 1;
+    (address[] memory tokens, uint256[] memory amounts) = parallelizer.quoteRedemptionCurve(bal);
+    for (uint256 i; i < tokens.length; ++i) {
+      total += _valueOf(tokens[i], amounts[i]);
+    }
+  }
+
+  function _redeem(address who, uint256 amount) internal {
+    (address[] memory tokens,) = parallelizer.quoteRedemptionCurve(amount);
+    uint256[] memory minOuts = new uint256[](tokens.length);
+    vm.prank(who);
+    parallelizer.redeem(amount, who, block.timestamp + 1 days, minOuts, keccak256(abi.encodePacked(tokens)));
+  }
+
+  /// @dev Alice's total position after the run, and what bob is left holding
+  function _run(uint256 redeemAmount, uint256 donation) internal returns (uint256 aliceNet, uint256 bobClaim) {
+    uint256 cost;
+    if (donation > 0) {
+      deal(address(eurB), alice, donation);
+      cost = _valueOf(address(eurB), donation);
+      vm.prank(alice);
+      IERC20(address(eurB)).transfer(address(parallelizer), donation);
+    }
+    _redeem(alice, redeemAmount);
+    aliceNet = _walletValue(alice) + _claimValue(alice) - cost;
+    bobClaim = _claimValue(bob);
+  }
+
+  /// @dev A curve with no upward segment: the reported ratio no longer prices the redemption, so a
+  /// donation has nothing to buy. `level` sets how much of a run deterrent is kept.
+  function _setFlatRedemptionCurve(int64 level) internal {
+    uint64[] memory x = new uint64[](2);
+    x[0] = 0;
+    x[1] = 1_000_000_000;
+    int64[] memory y = new int64[](2);
+    y[0] = level;
+    y[1] = level;
+    hoax(guardian);
+    parallelizer.setRedemptionCurveParams(x, y);
+  }
+
+  function _attackerNet(uint256 donation) internal returns (int256) {
+    _splitSupply(50);
+    uint256 amount = tokenP.balanceOf(alice);
+    uint256 inner = vm.snapshotState();
+    (uint256 baseAlice,) = _run(amount, 0);
+    vm.revertToState(inner);
+    (uint256 a,) = _run(amount, donation);
+    vm.revertToState(inner);
+    return int256(a) - int256(baseAlice);
+  }
+
+  /// @dev Flattening removes the profit at any level, so the level is free to serve the run
+  /// deterrent rather than the donation defence
+  function test_FlatCurve_RemovesTheDonationProfit() public {
+    uint256 donation = 2000e12;
+
+    int256 live = _attackerNet(donation);
+    console.log("live curve  (99.5 / 95 / 95 / 99.5)");
+    _log(live);
+
+    _setFlatRedemptionCurve(995_000_000);
+    int256 flatHigh = _attackerNet(donation);
+    console.log("flat at 99.5%, no deterrent kept");
+    _log(flatHigh);
+
+    _setFlatRedemptionCurve(950_000_000);
+    int256 flatLow = _attackerNet(donation);
+    console.log("flat at 95%, 5 point deterrent kept");
+    _log(flatLow);
+
+    assertGt(live, int256(0), "the deployed curve is exploitable at this share");
+    assertLt(flatHigh, int256(0), "flattening high must remove the profit");
+    assertLt(flatLow, int256(0), "flattening low must remove the profit");
+  }
+
+  /// @dev `y[last]` also prices every redemption above a 100% ratio, so flattening the curve at a
+  /// lower level would raise the fee paid in normal conditions
+  function test_FlatLevel_AlsoPricesHealthyRedemptions() public {
+    _setRatioTo(1_100_000_000);
+    _splitSupply(50);
+    uint256 amount = tokenP.balanceOf(alice);
+
+    uint256 snap = vm.snapshotState();
+    _setFlatRedemptionCurve(995_000_000);
+    _redeem(alice, amount);
+    uint256 at995 = _walletValue(alice);
+    vm.revertToState(snap);
+
+    _setFlatRedemptionCurve(950_000_000);
+    _redeem(alice, amount);
+    uint256 at950 = _walletValue(alice);
+    vm.revertToState(snap);
+
+    console.log("healthy redemption at a 110% ratio");
+    console.log("  proceeds with y[last] = 99.5%", at995);
+    console.log("  proceeds with y[last] = 95%  ", at950);
+    console.log("  cost of flattening low       ", at995 - at950);
+    assertGt(at995, at950, "a lower flat level taxes healthy redemptions");
+  }
+
+  /// @dev Same 4.5 point deterrent, ramping back to `y[last]` from `rampStart` up to a 100% ratio.
+  /// The attacker pays in ratio points and is paid in payout points, so the slope of that ramp is
+  /// what decides profitability, not whether a deterrent exists.
+  function _setRampedCurve(uint64 rampStart) internal {
+    uint64[] memory x = new uint64[](3);
+    x[0] = 0;
+    x[1] = rampStart;
+    x[2] = 1_000_000_000;
+    int64[] memory y = new int64[](3);
+    y[0] = 950_000_000;
+    y[1] = 950_000_000;
+    y[2] = 995_000_000;
+    hoax(guardian);
+    parallelizer.setRedemptionCurveParams(x, y);
+  }
+
+  function _attackerNetAtShare(uint256 sharePct, uint256 donation) internal returns (int256) {
+    _splitSupply(100 - sharePct);
+    uint256 amount = tokenP.balanceOf(alice);
+    uint256 inner = vm.snapshotState();
+    (uint256 baseAlice,) = _run(amount, 0);
+    vm.revertToState(inner);
+    (uint256 a,) = _run(amount, donation);
+    vm.revertToState(inner);
+    return int256(a) - int256(baseAlice);
+  }
+
+  /// @dev A gentle enough ramp keeps the deterrent and still starves the attack, including against
+  /// a holder large enough to recover most of their own donation
+  function test_RampSlope_DecidesProfitability() public {
+    uint256 donation = 2000e12;
+    uint64[4] memory rampStarts = [uint64(950_000_000), 900_000_000, 800_000_000, 600_000_000];
+    uint256[2] memory shares = [uint256(50), 90];
+
+    console.log("4.5 payout points ramping up to a 100% ratio, over a widening band");
+    for (uint256 i; i < rampStarts.length; ++i) {
+      uint256 width = 1_000_000_000 - rampStarts[i];
+      console.log("  ramp starts at (1e9)", rampStarts[i]);
+      console.log("    slope x1000", (uint256(45_000_000) * 1000) / width);
+      for (uint256 j; j < shares.length; ++j) {
+        uint256 snap = vm.snapshotState();
+        _setRampedCurve(rampStarts[i]);
+        int256 net = _attackerNetAtShare(shares[j], donation);
+        vm.revertToState(snap);
+        console.log("      attacker share pct", shares[j]);
+        _log(net);
+
+        // The attacker pays `d` in ratio points and is repaid `slope * d` in payout points on their
+        // own redemption, while recovering the share `f` of the donation they still have a claim
+        // on. So a ramp starves the attack when slope < (1 - f) / (f * H/S). At half the supply
+        // that threshold is about 1.05, at ninety percent about 0.12.
+        uint256 threshold = shares[j] == 50 ? 1053 : 117;
+        if ((uint256(45_000_000) * 1000) / width < threshold) {
+          assertLt(net, int256(0), "a ramp below the threshold must not pay");
+        } else {
+          assertGt(net, int256(0), "a ramp above the threshold still pays");
+        }
+      }
+    }
+  }
+
+  function _log(int256 net) internal pure {
+    if (net > 0) console.log("    attacker GAINS", uint256(net));
+    else console.log("    attacker LOSES", uint256(-net));
+  }
+
+  /// @dev Moves `pct` of the supply to bob, leaving alice with the rest
+  function _splitSupply(uint256 pctToBob) internal {
+    uint256 send = (tokenP.balanceOf(alice) * pctToBob) / 100;
+    vm.prank(alice);
+    IERC20(address(tokenP)).transfer(bob, send);
+  }
+
+  /// @dev Donation sized to walk the ratio from 95% up onto the 97% shoulder of the curve
+  function test_Measure_ProfitabilityByAttackerShare() public {
+    uint256[5] memory attackerPct = [uint256(25), 30, 35, 40, 50];
+    uint256 donation = 2000e12;
+
+    console.log("attacker share -> net result, donating 2000 of correctly priced collateral");
+    for (uint256 i; i < attackerPct.length; ++i) {
+      uint256 snap = vm.snapshotState();
+      _splitSupply(100 - attackerPct[i]);
+      uint256 amount = tokenP.balanceOf(alice);
+
+      uint256 inner = vm.snapshotState();
+      (uint256 baseAlice,) = _run(amount, 0);
+      vm.revertToState(inner);
+      (uint256 a, uint256 b) = _run(amount, donation);
+      uint256 baseBob;
+      {
+        vm.revertToState(inner);
+        (, baseBob) = _run(amount, 0);
+      }
+      vm.revertToState(snap);
+
+      console.log("  attacker holds pct", attackerPct[i]);
+      if (a > baseAlice) console.log("    attacker GAINS", a - baseAlice);
+      else console.log("    attacker LOSES", baseAlice - a);
+      if (b < baseBob) console.log("    others   LOSE ", baseBob - b);
+      else console.log("    others   gain ", b - baseBob);
+
+      // Break-even sits between 30% and 35% of the supply on the deployed curve. These bounds are
+      // the documented exposure: widening the curve's upward segment would move them, and this
+      // test is meant to fail so the trade-off gets re-measured.
+      if (attackerPct[i] <= 30) assertLt(a, baseAlice, "attack should not pay at this share");
+      if (attackerPct[i] >= 35) assertGt(a, baseAlice, "attack should still pay at this share");
+    }
+  }
+
+  function test_Measure_DonationTransfersValueFromOtherHolders() public {
+    _splitSupply(50);
+    uint256 startingAlice = tokenP.balanceOf(alice);
+    uint256[3] memory donations = [uint256(500e12), 2000e12, 5000e12];
+
+    uint256 snap = vm.snapshotState();
+    (uint256 baseAlice, uint256 baseBob) = _run(startingAlice, 0);
+    vm.revertToState(snap);
+    require(tokenP.balanceOf(alice) == startingAlice, "snapshot did not restore");
+
+    (uint64 crStart,) = parallelizer.getCollateralRatio();
+    console.log("starting collateral ratio (1e9)", crStart);
+    console.log("baseline, no donation");
+    console.log("  alice net position", baseAlice);
+    console.log("  bob   claim value", baseBob);
+
+    for (uint256 i; i < donations.length; ++i) {
+      snap = vm.snapshotState();
+      deal(address(eurB), alice, donations[i]);
+      vm.prank(alice);
+      IERC20(address(eurB)).transfer(address(parallelizer), donations[i]);
+      (uint64 crAfter,) = parallelizer.getCollateralRatio();
+      vm.revertToState(snap);
+
+      snap = vm.snapshotState();
+      (uint256 a, uint256 b) = _run(startingAlice, donations[i]);
+      uint256 eurBBack = IERC20(address(eurB)).balanceOf(alice);
+      vm.revertToState(snap);
+      require(tokenP.balanceOf(alice) == startingAlice, "snapshot did not restore");
+
+      console.log("donation oracle value", _valueOfStatic(donations[i]));
+      console.log("  ratio moves to (1e9)", crAfter);
+      console.log("  eurB returned to alice (oracle value)", _valueOfStatic(eurBBack));
+      if (a > baseAlice) console.log("  alice GAINS", a - baseAlice);
+      else console.log("  alice LOSES", baseAlice - a);
+      if (b < baseBob) console.log("  bob   LOSES", baseBob - b);
+      else console.log("  bob   gains", b - baseBob);
+    }
+  }
+
+  function _valueOfStatic(uint256 amount) internal view returns (uint256) {
+    return _valueOf(address(eurB), amount);
+  }
+}

From 6e12402349b197d4e4868c0ba6a8fadaeeb4e17c Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 8 Sep 2026 12:03:01 +0300
Subject: [PATCH 19/38] fix(redeemer): ramp the redemption curve out of
 donation range

The deployed curve returned to 99.5% over two ratio points, a slope of 2.25. An
attacker pays in ratio points and is repaid in payout points on their own
redemption while recovering the share they still hold a claim on, so a donation
pays whenever that slope exceeds (1 - f) / (f * H/S): about 1.05 against half the
supply, about 0.12 against ninety percent.

  x  75%    85%    95%    97%          ->   0      60%    100%
  y  99.5%  95%    95%    99.5%        ->   95%    95%    99.5%

The same 4.5 point deterrent now spans a 60% to 100% band, a slope of 0.112,
under the threshold even for a holder of ninety percent of the supply. `y[last]`
stays at 99.5% because it also prices every redemption above a 100% ratio.

Ramping monotonically also drops the previous shape's oddity of paying its best
rate at the deepest undercollateralization.

Carried in the six deploy configs for fresh deployments, and in
`SetRedemptionCurve.s.sol` for the five live ones, one run per chain.

Bailsec Core Issue_10
---
 deploy/config/avalanche/config.json |  4 ++--
 deploy/config/base/config.json      |  4 ++--
 deploy/config/hyperevm/config.json  |  4 ++--
 deploy/config/mainnet/config.json   |  4 ++--
 deploy/config/sepolia/config.json   |  4 ++--
 deploy/config/sonic/config.json     |  4 ++--
 scripts/SetRedemptionCurve.s.sol    | 37 +++++++++++++++++++++++++++++
 7 files changed, 49 insertions(+), 12 deletions(-)
 create mode 100644 scripts/SetRedemptionCurve.s.sol

diff --git a/deploy/config/avalanche/config.json b/deploy/config/avalanche/config.json
index 3594b30..1a0b34d 100644
--- a/deploy/config/avalanche/config.json
+++ b/deploy/config/avalanche/config.json
@@ -48,8 +48,8 @@
         }
       ],
       "redemptionSetup": {
-        "xRedeemFee": [750000000, 850000000, 950000000, 970000000],
-        "yRedeemFee": [995000000, 950000000, 950000000, 995000000]
+        "xRedeemFee": [0, 600000000, 1000000000],
+        "yRedeemFee": [950000000, 950000000, 995000000]
       }
     }
   },
diff --git a/deploy/config/base/config.json b/deploy/config/base/config.json
index beb60e7..3bae2fc 100644
--- a/deploy/config/base/config.json
+++ b/deploy/config/base/config.json
@@ -48,8 +48,8 @@
         }
       ],
       "redemptionSetup": {
-        "xRedeemFee": [750000000, 850000000, 950000000, 970000000],
-        "yRedeemFee": [995000000, 950000000, 950000000, 995000000]
+        "xRedeemFee": [0, 600000000, 1000000000],
+        "yRedeemFee": [950000000, 950000000, 995000000]
       }
     }
   },
diff --git a/deploy/config/hyperevm/config.json b/deploy/config/hyperevm/config.json
index e98b3dc..2ff7831 100644
--- a/deploy/config/hyperevm/config.json
+++ b/deploy/config/hyperevm/config.json
@@ -51,8 +51,8 @@
         }
       ],
       "redemptionSetup": {
-        "xRedeemFee": [750000000, 850000000, 950000000, 970000000],
-        "yRedeemFee": [995000000, 950000000, 950000000, 995000000]
+        "xRedeemFee": [0, 600000000, 1000000000],
+        "yRedeemFee": [950000000, 950000000, 995000000]
       }
     }
   },
diff --git a/deploy/config/mainnet/config.json b/deploy/config/mainnet/config.json
index 236a4ff..b47a24b 100644
--- a/deploy/config/mainnet/config.json
+++ b/deploy/config/mainnet/config.json
@@ -88,8 +88,8 @@
         }
       ],
       "redemptionSetup": {
-        "xRedeemFee": [750000000, 850000000, 950000000, 970000000],
-        "yRedeemFee": [995000000, 950000000, 950000000, 995000000]
+        "xRedeemFee": [0, 600000000, 1000000000],
+        "yRedeemFee": [950000000, 950000000, 995000000]
       }
     }
   },
diff --git a/deploy/config/sepolia/config.json b/deploy/config/sepolia/config.json
index e5c071c..2cb18d0 100644
--- a/deploy/config/sepolia/config.json
+++ b/deploy/config/sepolia/config.json
@@ -31,8 +31,8 @@
         }
       ],
       "redemptionSetup": {
-        "xRedeemFee": [750000000, 850000000, 950000000, 970000000],
-        "yRedeemFee": [995000000, 950000000, 950000000, 995000000]
+        "xRedeemFee": [0, 600000000, 1000000000],
+        "yRedeemFee": [950000000, 950000000, 995000000]
       }
     }
   },
diff --git a/deploy/config/sonic/config.json b/deploy/config/sonic/config.json
index 4a2a45c..03709ce 100644
--- a/deploy/config/sonic/config.json
+++ b/deploy/config/sonic/config.json
@@ -88,8 +88,8 @@
         }
       ],
       "redemptionSetup": {
-        "xRedeemFee": [750000000, 850000000, 950000000, 970000000],
-        "yRedeemFee": [995000000, 950000000, 950000000, 995000000]
+        "xRedeemFee": [0, 600000000, 1000000000],
+        "yRedeemFee": [950000000, 950000000, 995000000]
       }
     }
   },
diff --git a/scripts/SetRedemptionCurve.s.sol b/scripts/SetRedemptionCurve.s.sol
new file mode 100644
index 0000000..8d7de72
--- /dev/null
+++ b/scripts/SetRedemptionCurve.s.sol
@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.28;
+
+import "./Base.s.sol";
+
+import { ISettersGuardian } from "contracts/interfaces/ISetters.sol";
+
+/// @notice Replaces the redemption curve with a ramp gentle enough that a donation cannot pay for
+/// the coefficient it buys. Bailsec Core Issue_10.
+///
+/// The previous curve returned to 99.5% over two ratio points, a slope of 2.25. An attacker pays in
+/// ratio points and is repaid in payout points on their own redemption, while recovering the share
+/// `f` they still hold a claim on, so the attack pays whenever the slope exceeds
+/// (1 - f) / (f * H/S): about 1.05 against half the supply, about 0.12 against ninety percent.
+///
+/// The same 4.5 point deterrent now spans a 60% to 100% ratio band, a slope of 0.112, which stays
+/// under the threshold even for a holder of ninety percent of the supply. Ramping monotonically also
+/// drops the old shape's oddity of paying its best rate at the deepest undercollateralization.
+///
+/// Run once per chain, against that chain's Parallelizer.
+contract SetRedemptionCurve is BaseScript {
+  address internal constant PARALLELIZER = 0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2;
+
+  function run() public broadcast {
+    uint64[] memory xFee = new uint64[](3);
+    xFee[0] = 0;
+    xFee[1] = 600_000_000; // 60% collateral ratio
+    xFee[2] = 1_000_000_000; // 100% collateral ratio
+
+    int64[] memory yFee = new int64[](3);
+    yFee[0] = 950_000_000; // 95% payout, the deterrent floor
+    yFee[1] = 950_000_000;
+    yFee[2] = 995_000_000; // 99.5%, also the fee every healthy redemption pays
+
+    ISettersGuardian(PARALLELIZER).setRedemptionCurveParams(xFee, yFee);
+  }
+}

From ec5f1dffb0b513168132f687a6d4570362fc0189 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 8 Sep 2026 13:25:34 +0300
Subject: [PATCH 20/38] fix(oracle): move the deviation tolerance onto the burn
 side

Bailsec Core Issue_22 asks that fees be set so `userDeviation` cannot be
exploited. Reading the code, the finding points instead at a live configuration
the contract already refuses to accept.

`userDeviation` replaces a spot inside its band with the target for both mint and
burn. So `readMint` credits a discounted collateral at face value, and because
the snap runs before the burn firewall, the collateral stops contributing any
depeg haircut while it sits inside the band.

`setOracle` already guards this:

  if (userDeviation > burnRatioDeviation) revert InvalidParams();

The invariant is exactly right: while the snap applies the firewall would not
have fired anyway, so the snap can never suppress it. Two mainnet collaterals
violate it, pairing a 5 bps snap band with a zero firewall band, and they predate
the check. `DiamondInitializer` routes through the same `setOracle`, so the
shipped config would no longer deploy.

The tolerance moves to the burn side, matching the two collaterals already
configured that way. Measured, nothing is lost:

                mint pricing                  firewall 4 bps   firewall 20 bps
  before        face value, discount taken    suppressed       suppressed
  after         true spot, discount to minter tolerated        engages

Seven collateral entries across five chains corrected in the deploy configs.
Governance must apply the same change on chain through `setOracle`.
---
 deploy/config/avalanche/config.json |   4 +-
 deploy/config/base/config.json      |   4 +-
 deploy/config/hyperevm/config.json  |   4 +-
 deploy/config/mainnet/config.json   |   8 +--
 deploy/config/sonic/config.json     |   8 +--
 tests/units/UserDeviation.t.sol     | 100 ++++++++++++++++++++++++++++
 6 files changed, 114 insertions(+), 14 deletions(-)
 create mode 100644 tests/units/UserDeviation.t.sol

diff --git a/deploy/config/avalanche/config.json b/deploy/config/avalanche/config.json
index 1a0b34d..43805cd 100644
--- a/deploy/config/avalanche/config.json
+++ b/deploy/config/avalanche/config.json
@@ -20,8 +20,8 @@
             "circuitChainIsMultiplied": [1],
             "chainlinkDecimals": [8],
             "hyperparameters": {
-              "userDeviation": 500000000000000,
-              "burnRatioDeviation": 0
+              "userDeviation": 0,
+              "burnRatioDeviation": 500000000000000
             }
           },
           "xMintFee": [0],
diff --git a/deploy/config/base/config.json b/deploy/config/base/config.json
index 3bae2fc..dd632e9 100644
--- a/deploy/config/base/config.json
+++ b/deploy/config/base/config.json
@@ -20,8 +20,8 @@
             "circuitChainIsMultiplied": [1],
             "chainlinkDecimals": [8],
             "hyperparameters": {
-              "userDeviation": 500000000000000,
-              "burnRatioDeviation": 0
+              "userDeviation": 0,
+              "burnRatioDeviation": 500000000000000
             }
           },
           "xMintFee": [0],
diff --git a/deploy/config/hyperevm/config.json b/deploy/config/hyperevm/config.json
index 2ff7831..90931c1 100644
--- a/deploy/config/hyperevm/config.json
+++ b/deploy/config/hyperevm/config.json
@@ -20,8 +20,8 @@
             "circuitChainIsMultiplied": [1],
             "chainlinkDecimals": [8],
             "hyperparameters": {
-              "userDeviation": 500000000000000,
-              "burnRatioDeviation": 0
+              "userDeviation": 0,
+              "burnRatioDeviation": 500000000000000
             }
           },
           "xMintFee": [0],
diff --git a/deploy/config/mainnet/config.json b/deploy/config/mainnet/config.json
index b47a24b..6d0d0c8 100644
--- a/deploy/config/mainnet/config.json
+++ b/deploy/config/mainnet/config.json
@@ -20,8 +20,8 @@
             "circuitChainIsMultiplied": [1],
             "chainlinkDecimals": [8],
             "hyperparameters": {
-              "userDeviation": 500000000000000,
-              "burnRatioDeviation": 0
+              "userDeviation": 0,
+              "burnRatioDeviation": 500000000000000
             }
           },
           "xMintFee": [0],
@@ -57,8 +57,8 @@
             "circuitChainIsMultiplied": [1],
             "chainlinkDecimals": [8],
             "hyperparameters": {
-              "userDeviation": 500000000000000,
-              "burnRatioDeviation": 0
+              "userDeviation": 0,
+              "burnRatioDeviation": 500000000000000
             }
           },
           "xMintFee": [0],
diff --git a/deploy/config/sonic/config.json b/deploy/config/sonic/config.json
index 03709ce..d709173 100644
--- a/deploy/config/sonic/config.json
+++ b/deploy/config/sonic/config.json
@@ -20,8 +20,8 @@
             "circuitChainIsMultiplied": [1],
             "chainlinkDecimals": [8],
             "hyperparameters": {
-              "userDeviation": 500000000000000,
-              "burnRatioDeviation": 0
+              "userDeviation": 0,
+              "burnRatioDeviation": 500000000000000
             }
           },
           "xMintFee": [0],
@@ -57,8 +57,8 @@
             "circuitChainIsMultiplied": [1],
             "chainlinkDecimals": [8],
             "hyperparameters": {
-              "userDeviation": 500000000000000,
-              "burnRatioDeviation": 0
+              "userDeviation": 0,
+              "burnRatioDeviation": 500000000000000
             }
           },
           "xMintFee": [0],
diff --git a/tests/units/UserDeviation.t.sol b/tests/units/UserDeviation.t.sol
new file mode 100644
index 0000000..9fa944e
--- /dev/null
+++ b/tests/units/UserDeviation.t.sol
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity 0.8.28;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { console } from "@forge-std/console.sol";
+
+import { MockChainlinkOracle } from "../mock/MockChainlinkOracle.sol";
+import { Fixture } from "../Fixture.sol";
+import { OracleReadType } from "contracts/parallelizer/Storage.sol";
+import "contracts/utils/Constants.sol";
+import "contracts/utils/Errors.sol" as Errors;
+
+/// @notice Bailsec Core Issue_22. `userDeviation` snaps a spot inside its band up to the target for
+/// both mint and burn, so a collateral bought at a discount mints at face value. The band is also
+/// what keeps ordinary oracle noise from tripping the burn firewall, which is why zeroing it is not
+/// the answer.
+contract Test_UserDeviation is Fixture {
+  function _oracleConfig(
+    address collateral,
+    uint128 userDeviation,
+    uint128 burnRatioDeviation
+  )
+    internal
+    view
+    returns (bytes memory)
+  {
+    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =
+      parallelizer.getOracle(collateral);
+    return abi.encode(oracleType, targetType, oracleData, targetData, abi.encode(userDeviation, burnRatioDeviation));
+  }
+
+  function _setDeviations(address collateral, uint128 userDeviation, uint128 burnRatioDeviation) internal {
+    bytes memory config = _oracleConfig(collateral, userDeviation, burnRatioDeviation);
+    hoax(governor);
+    parallelizer.setOracle(collateral, config);
+  }
+
+  /// @dev eurA quoted `bps` basis points under its target
+  function _discountEurA(uint256 bps) internal {
+    MockChainlinkOracle(address(oracleA)).setLatestAnswer(int256((BASE_8 * (10_000 - bps)) / 10_000));
+  }
+
+  function _mintValue(uint256 amountIn) internal returns (uint256 tokenPOut) {
+    deal(address(eurA), alice, amountIn);
+    vm.startPrank(alice);
+    IERC20(address(eurA)).approve(address(parallelizer), amountIn);
+    uint256 before = tokenP.balanceOf(alice);
+    parallelizer.swapExactInput(amountIn, 0, address(eurA), address(tokenP), alice, block.timestamp + 1 days);
+    tokenPOut = tokenP.balanceOf(alice) - before;
+    vm.stopPrank();
+  }
+
+  /// @dev `setOracle` refuses a snap band wider than the firewall band, which is exactly the
+  /// pairing two mainnet collaterals carry today. They predate the check, and `DiamondInitializer`
+  /// routes through the same `setOracle`, so the current config would not deploy.
+  function test_SetOracle_RejectsTheLiveMainnetPairing() public {
+    bytes memory config = _oracleConfig(address(eurA), 5e14, 0);
+    hoax(governor);
+    vm.expectRevert(Errors.InvalidParams.selector);
+    parallelizer.setOracle(address(eurA), config);
+  }
+
+  /// @dev Moving the same tolerance to the burn side prices the mint at the true spot, so the
+  /// discount is no longer captured
+  function test_ToleranceOnTheBurnSide_PricesTheMintCorrectly() public {
+    _setDeviations(address(eurA), 0, 5e14);
+
+    uint256 snap = vm.snapshotState();
+    uint256 atPeg = _mintValue(10_000 * BASE_6);
+    vm.revertToState(snap);
+
+    _discountEurA(4);
+    uint256 discounted = _mintValue(10_000 * BASE_6);
+
+    console.log("userDeviation 0, burnRatioDeviation 5bps");
+    console.log("  tokenP minted at peg            ", atPeg);
+    console.log("  tokenP minted 4 bps under peg   ", discounted);
+    console.log("  shortfall carried by the minter ", atPeg - discounted);
+    assertLt(discounted, atPeg, "the discount must reach the minter, not the protocol");
+    // the shortfall tracks the 4 bps discount rather than being absorbed by the reserve
+    assertApproxEqRel(atPeg - discounted, (atPeg * 4) / 10_000, 0.02e18, "shortfall should track the spot");
+  }
+
+  /// @dev And the burn firewall still tolerates the same noise, so nothing is lost by the move
+  function test_ToleranceOnTheBurnSide_StillAbsorbsOracleNoise() public {
+    _setDeviations(address(eurA), 0, 5e14);
+    _discountEurA(4);
+
+    (,, uint256 ratio,,) = parallelizer.getOracleValues(address(eurA));
+    console.log("burn ratio with a 4 bps depeg, tolerance on the burn side", ratio);
+    assertEq(ratio, BASE_18, "a 4 bps wobble must not haircut every burn");
+
+    // past the band the firewall engages as intended
+    _discountEurA(20);
+    (,, ratio,,) = parallelizer.getOracleValues(address(eurA));
+    console.log("burn ratio with a 20 bps depeg", ratio);
+    assertLt(ratio, BASE_18, "a real depeg must still haircut burns");
+  }
+}

From 7648a26bf1915e3dda8dc73317715be9f8deb23c Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 8 Sep 2026 15:11:57 +0300
Subject: [PATCH 21/38] fix(surplus): reject the Parallelizer itself as a payee

`_addPayee` validated only that the share was non-zero. The Parallelizer holds
the income being distributed, so a share allocated to itself is handed straight
back to `release` as fresh income on the next call, redistributing itself.

`address(0)` deliberately stays valid. `LibSurplus._release` treats it as the
sentinel for burning that share, and the live surplus policy uses it. An earlier
draft rejected both and broke the surplus tests, which is how the sentinel
surfaced.

Bailsec Core Issue_19
---
 .../parallelizer/libraries/LibSetters.sol     |  4 +++
 contracts/utils/Errors.sol                    |  1 +
 tests/units/Setters.t.sol                     | 26 +++++++++++++++++++
 3 files changed, 31 insertions(+)

diff --git a/contracts/parallelizer/libraries/LibSetters.sol b/contracts/parallelizer/libraries/LibSetters.sol
index 7de70b5..8154ad6 100644
--- a/contracts/parallelizer/libraries/LibSetters.sol
+++ b/contracts/parallelizer/libraries/LibSetters.sol
@@ -382,6 +382,10 @@ library LibSetters {
   /// @param _shares The number of shares assigned to the fee receiver.
   function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {
     if (_shares == 0) revert ZeroAmount();
+    // The Parallelizer holds the income being distributed, so a share allocated to itself is handed
+    // back to `release` as fresh income on the next call. `address(0)` stays valid: `LibSurplus`
+    // treats it as the sentinel for burning that share.
+    if (_payee == address(this)) revert InvalidPayee();
     ParallelizerStorage storage ts = s.transmuterStorage();
 
     ts.payees.push(_payee);
diff --git a/contracts/utils/Errors.sol b/contracts/utils/Errors.sol
index 6127e29..53501a9 100644
--- a/contracts/utils/Errors.sol
+++ b/contracts/utils/Errors.sol
@@ -26,6 +26,7 @@ error InvalidNegativeFees();
 error InvalidOracleType();
 error InvalidParam();
 error InvalidParams();
+error InvalidPayee();
 error InvalidRate();
 error InvalidSwap();
 error InvalidTokens();
diff --git a/tests/units/Setters.t.sol b/tests/units/Setters.t.sol
index 5e251e0..efddb50 100644
--- a/tests/units/Setters.t.sol
+++ b/tests/units/Setters.t.sol
@@ -1528,6 +1528,32 @@ contract Test_Setters_UpdatePayees is Fixture {
     assertEq(parallelizer.getTotalShares(), 3 ether);
   }
 
+  /// @dev Bailsec Core Issue_19: a share allocated to the Parallelizer is handed back to `release`
+  /// as fresh income on the next call, so it recursively redistributes itself
+  function test_RevertWhen_PayeeIsTheParallelizer() public {
+    address[] memory payees = new address[](1);
+    payees[0] = address(parallelizer);
+    uint256[] memory shares = new uint256[](1);
+    shares[0] = 1 ether;
+
+    hoax(governor);
+    vm.expectRevert(Errors.InvalidPayee.selector);
+    parallelizer.updatePayees(payees, shares, false);
+  }
+
+  /// @dev `address(0)` is the sentinel `LibSurplus` uses to burn a share, so it stays valid
+  function test_PayeeCanBeZeroAddress() public {
+    address[] memory payees = new address[](1);
+    payees[0] = address(0);
+    uint256[] memory shares = new uint256[](1);
+    shares[0] = 1 ether;
+
+    hoax(governor);
+    parallelizer.updatePayees(payees, shares, false);
+
+    assertEq(parallelizer.getShares(address(0)), 1 ether);
+  }
+
   modifier initializePayees() {
     address[] memory payees = new address[](1);
     payees[0] = address(alice);

From 95c5ccb90aedfd2590756d6be3362e1e3c0a8ca6 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 8 Sep 2026 15:18:45 +0300
Subject: [PATCH 22/38] style(tests): wrap the over-length line the ratchet
 test introduced

`bun run lint:sol` reports it as an error rather than a warning, so it would fail
CI. Introduced by the Issue_04 fix.
---
 tests/fuzz/Oracle.t.sol | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/fuzz/Oracle.t.sol b/tests/fuzz/Oracle.t.sol
index a2f7505..c461910 100644
--- a/tests/fuzz/Oracle.t.sol
+++ b/tests/fuzz/Oracle.t.sol
@@ -726,9 +726,10 @@ contract OracleTest is Fixture, FunctionUtils {
     (uint256 oracleValue,,,,) = parallelizer.getOracleValues(collateral);
 
     vm.prank(governor);
+    bytes memory hyperparameters = abi.encode(uint128(0), uint128(0));
     parallelizer.setOracle(
       collateral,
-      abi.encode(readType, Storage.OracleReadType.MAX, data, abi.encode(oracleValue), abi.encode(uint128(0), uint128(0)))
+      abi.encode(readType, Storage.OracleReadType.MAX, data, abi.encode(oracleValue), hyperparameters)
     );
 
     (, int256 currentValue,,,) = _oracles[0].latestRoundData();

From eae104c8aa54799e9aa6a7ba75ac221cff212cf4 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 28 Sep 2026 10:08:17 +0300
Subject: [PATCH 23/38] fix(oracle): seed the MAX target at deployment instead
 of leaving it at zero

The ratchet bounds each step against the stored target, so a target left at 0
can never be raised: every positive spot exceeds 0 by more than 5%. New chains
would deploy with a permanently frozen oracle.

The initializer now seeds the target from spot once, and the ratchet governs
every later move. Seeding is refused on an already-set target, so it cannot be
used to sidestep the bound.

Reported by Bailsec against the Issue_04 remediation.
---
 .../configs/DiamondInitializer.sol            |  2 +-
 .../parallelizer/libraries/LibOracle.sol      | 27 +++++++++++++++++++
 tests/fuzz/Oracle.t.sol                       | 22 +++++++++++++++
 3 files changed, 50 insertions(+), 1 deletion(-)

diff --git a/contracts/parallelizer/configs/DiamondInitializer.sol b/contracts/parallelizer/configs/DiamondInitializer.sol
index 7f1c428..457b394 100644
--- a/contracts/parallelizer/configs/DiamondInitializer.sol
+++ b/contracts/parallelizer/configs/DiamondInitializer.sol
@@ -33,7 +33,7 @@ contract DiamondInitializer {
       LibSetters.unpause(collateral.token, ActionType.Mint);
       LibSetters.unpause(collateral.token, ActionType.Burn);
       LibSetters.setStablecoinCap(collateral.token, 100_000_000 ether);
-      if (collateral.targetMax) LibOracle.updateOracle(collateral.token);
+      if (collateral.targetMax) LibOracle.initializeOracleTarget(collateral.token);
     }
 
     // setRedemptionCurveParams
diff --git a/contracts/parallelizer/libraries/LibOracle.sol b/contracts/parallelizer/libraries/LibOracle.sol
index 54431f8..c400e70 100644
--- a/contracts/parallelizer/libraries/LibOracle.sol
+++ b/contracts/parallelizer/libraries/LibOracle.sol
@@ -241,6 +241,33 @@ library LibOracle {
     return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));
   }
 
+  /// @notice Seeds the MAX target with the current spot, for a collateral that has never been ratcheted
+  /// @dev `updateOracle` bounds every step to `MAX_ORACLE_RATCHET_STEP` against the stored target, so a target
+  /// left at 0 can never be raised. Deployment goes through here once, then the ratchet takes over
+  function initializeOracleTarget(address collateral) internal {
+    ParallelizerStorage storage ts = s.transmuterStorage();
+    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();
+
+    (
+      OracleReadType oracleType,
+      OracleReadType targetType,
+      bytes memory oracleData,
+      bytes memory targetData,
+      bytes memory hyperparameters
+    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);
+
+    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();
+    // Only an unset target may be seeded, so this cannot be used to sidestep the ratchet later on
+    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();
+
+    uint256 oracleValue = read(oracleType, BASE_18, oracleData);
+    if (oracleValue == 0) revert OracleUpdateFailed();
+
+    ts.collaterals[collateral].oracleConfig =
+      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);
+    emit OracleTargetUpdated(collateral, 0, oracleValue);
+  }
+
   function updateOracle(address collateral) internal {
     ParallelizerStorage storage ts = s.transmuterStorage();
     if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();
diff --git a/tests/fuzz/Oracle.t.sol b/tests/fuzz/Oracle.t.sol
index c461910..790b157 100644
--- a/tests/fuzz/Oracle.t.sol
+++ b/tests/fuzz/Oracle.t.sol
@@ -742,6 +742,28 @@ contract OracleTest is Fixture, FunctionUtils {
     parallelizer.updateOracle(collateral);
   }
 
+  function test_updateOracle_CannotLiftATargetLeftAtZero() public {
+    vm.prank(governor);
+    parallelizer.toggleTrusted(alice, Storage.TrustedType.Seller);
+
+    address collateral = _collaterals[0];
+    (Storage.OracleReadType readType,, bytes memory data,,) = parallelizer.getOracle(collateral);
+
+    // A MAX target seeded with 0, which is what the deployment script encoded before the initializer seeded spot
+    vm.prank(governor);
+    parallelizer.setOracle(
+      collateral,
+      abi.encode(
+        readType, Storage.OracleReadType.MAX, data, abi.encode(uint256(0)), abi.encode(uint128(0), uint128(0))
+      )
+    );
+
+    // Every positive spot is above 0 by more than the ratchet step, so the target can never be raised
+    vm.prank(alice);
+    vm.expectRevert(Errors.OracleUpdateFailed.selector);
+    parallelizer.updateOracle(collateral);
+  }
+
   function testFuzz_updateOracle_Success(uint256 updateOracleValue, uint32 heartbeat) public {
     vm.prank(governor);
     parallelizer.toggleTrusted(alice, Storage.TrustedType.Seller);

From 9a35f75ebc5930ba366589e6cb1e37c25afe0381 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 28 Sep 2026 10:08:17 +0300
Subject: [PATCH 24/38] fix(rebalancer): clear the deposit address approval
 when the asset rotates

Asset rotation cleared `oldUnderlying -> yieldBearingAsset`, the vault path's
relationship. The MultiBlock deposit path instead approves
`underlying -> depositAddress`, so that allowance survived the rotation and the
regression test asserted the same wrong pair.

A virtual hook lets each rebalancer revoke what it actually granted. The new
test fails without the override.

Reported by Bailsec against the Issue_02 remediation.
---
 contracts/helpers/BaseRebalancer.sol          |  6 +++++
 contracts/helpers/MultiBlockRebalancer.sol    | 10 ++++++++
 .../units/DonationRedemptionCoefficient.t.sol | 24 +++++++++++++++++++
 tests/units/Rebalancer.t.sol                  | 12 ++++++++++
 4 files changed, 52 insertions(+)

diff --git a/contracts/helpers/BaseRebalancer.sol b/contracts/helpers/BaseRebalancer.sol
index 19abd87..e313579 100644
--- a/contracts/helpers/BaseRebalancer.sol
+++ b/contracts/helpers/BaseRebalancer.sol
@@ -265,6 +265,7 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
     if (previousAsset != address(0) && previousAsset != asset) {
       IERC20(previousAsset).forceApprove(yieldBearingAsset, 0);
       emit AllowanceReset(previousAsset, yieldBearingAsset);
+      _revokeAssetAllowances(yieldBearingAsset, previousAsset);
     }
     yieldBearingInfo.asset = asset;
     if (targetExposure >= 1e9) revert InvalidParam();
@@ -282,6 +283,11 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
     }
   }
 
+  /// @notice Revokes the allowances a derived rebalancer granted over an asset being rotated out
+  /// @dev `_setYieldBearingAssetData` only clears the `asset -> yieldBearingAsset` approval the vault path uses.
+  /// A rebalancer that approves a different spender overrides this to clear its own relationship
+  function _revokeAssetAllowances(address yieldBearingAsset, address previousAsset) internal virtual { }
+
   function _updateLimitExposuresYieldAsset(
     address asset,
     YieldBearingParams storage yieldBearingInfo
diff --git a/contracts/helpers/MultiBlockRebalancer.sol b/contracts/helpers/MultiBlockRebalancer.sol
index 172ab3c..421b28a 100644
--- a/contracts/helpers/MultiBlockRebalancer.sol
+++ b/contracts/helpers/MultiBlockRebalancer.sol
@@ -62,6 +62,16 @@ contract MultiBlockRebalancer is BaseRebalancer {
     yieldBearingToDepositAddress[yieldBearingAsset] = newDepositAddress;
   }
 
+  /// @inheritdoc BaseRebalancer
+  /// @dev The deposit path approves `asset -> depositAddress`, so rotating the asset has to clear that too
+  function _revokeAssetAllowances(address yieldBearingAsset, address previousAsset) internal override {
+    address depositAddress = yieldBearingToDepositAddress[yieldBearingAsset];
+    if (depositAddress != address(0)) {
+      IERC20(previousAsset).forceApprove(depositAddress, 0);
+      emit AllowanceReset(previousAsset, depositAddress);
+    }
+  }
+
   /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                         TRUSTED FUNCTIONS
   //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
diff --git a/tests/units/DonationRedemptionCoefficient.t.sol b/tests/units/DonationRedemptionCoefficient.t.sol
index 7a8082d..fdf2fa9 100644
--- a/tests/units/DonationRedemptionCoefficient.t.sol
+++ b/tests/units/DonationRedemptionCoefficient.t.sol
@@ -230,6 +230,30 @@ contract Test_DonationRedemptionCoefficient is Fixture {
     }
   }
 
+  /// @dev Bailsec's residual case needs the system to be undercollateralised. Once the ratio reaches
+  /// 100% the curve sits at its cap, the donation buys no coefficient lift, and the attacker is left
+  /// paying the spread on the collateral they donated
+  function test_Overcollateralized_RemovesTheDonationProfit() public {
+    uint256 donation = 2000e12;
+
+    uint256 snap = vm.snapshotState();
+    _setRampedCurve(600_000_000);
+    int256 under = _attackerNetAtShare(90, donation);
+    vm.revertToState(snap);
+
+    snap = vm.snapshotState();
+    _setRampedCurve(600_000_000);
+    _setRatioTo(1_050_000_000);
+    int256 over = _attackerNetAtShare(90, donation);
+    vm.revertToState(snap);
+
+    console.log("undercollateralised:");
+    _log(under);
+    console.log("overcollateralised:");
+    _log(over);
+    assertLt(over, int256(0), "an overcollateralised system must not pay the donation attack");
+  }
+
   function _log(int256 net) internal pure {
     if (net > 0) console.log("    attacker GAINS", uint256(net));
     else console.log("    attacker LOSES", uint256(-net));
diff --git a/tests/units/Rebalancer.t.sol b/tests/units/Rebalancer.t.sol
index 37e7963..cef902b 100644
--- a/tests/units/Rebalancer.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -177,6 +177,18 @@ contract Test_Rebalancer_Allowances is Fixture {
     assertEq(IERC20(address(eurA)).allowance(address(rebalancer), address(eurY)), type(uint256).max);
   }
 
+  function test_RotatingTheAsset_RevokesTheDepositAddressAllowance() public {
+    vm.prank(governor);
+    rebalancer.setYieldBearingToDepositAddress(address(eurY), bob);
+    // The deposit path approves the underlying to the deposit address, not to the yield bearing asset
+    _seedAllowance(address(eurA), bob);
+
+    vm.prank(guardian);
+    rebalancer.setYieldBearingAssetData(address(eurY), address(eurB), 5e8, 1e8, 9e8, 1, 5e7);
+
+    assertEq(IERC20(address(eurA)).allowance(address(rebalancer), bob), 0);
+  }
+
   function test_RotatingTheDepositAddress_RevokesTheOutgoingAllowance() public {
     vm.prank(governor);
     rebalancer.setYieldBearingToDepositAddress(address(eurY), bob);

From ce9c01637894fbcda0e8ac13bc4ef54a563b8dc8 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 28 Sep 2026 11:00:52 +0300
Subject: [PATCH 25/38] test(redemption): pin the donation attack against the
 surplus buffer steady state

processSurplus drives the ratio to surplusBufferRatio, 100.5% on mainnet, so the
margin over the profitable region is under a point rather than the headroom a
spot reading suggests.

The measurements also correct the earlier framing: the break-even sits just under
100% whatever the ramp, so the defence is the cap at 100% rather than the slope.
Widening the ramp or trimming the deterrent barely moves it.
---
 .../units/DonationRedemptionCoefficient.t.sol | 29 ++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/tests/units/DonationRedemptionCoefficient.t.sol b/tests/units/DonationRedemptionCoefficient.t.sol
index fdf2fa9..49704ba 100644
--- a/tests/units/DonationRedemptionCoefficient.t.sol
+++ b/tests/units/DonationRedemptionCoefficient.t.sol
@@ -232,7 +232,8 @@ contract Test_DonationRedemptionCoefficient is Fixture {
 
   /// @dev Bailsec's residual case needs the system to be undercollateralised. Once the ratio reaches
   /// 100% the curve sits at its cap, the donation buys no coefficient lift, and the attacker is left
-  /// paying the spread on the collateral they donated
+  /// paying the spread on the collateral they donated. The defence is the 100% kink rather than the
+  /// slope: widening the ramp barely moves the break-even, which sits just under 100% either way
   function test_Overcollateralized_RemovesTheDonationProfit() public {
     uint256 donation = 2000e12;
 
@@ -254,6 +255,32 @@ contract Test_DonationRedemptionCoefficient is Fixture {
     assertLt(over, int256(0), "an overcollateralised system must not pay the donation attack");
   }
 
+  /// @dev `processSurplus` drives the ratio down to `surplusBufferRatio`, 100.5% on mainnet, so the
+  /// margin over the profitable region is under a point rather than the headroom a fresh reading
+  /// suggests. This pins where the donation attack turns positive from that steady state
+  function test_SurplusBufferSteadyState_LeavesAThinMargin() public {
+    uint256 donation = 2000e12;
+
+    uint256 snap = vm.snapshotState();
+    _setRampedCurve(600_000_000);
+    _setRatioTo(1_005_000_000);
+    int256 atBuffer = _attackerNetAtShare(90, donation);
+    vm.revertToState(snap);
+
+    snap = vm.snapshotState();
+    _setRampedCurve(600_000_000);
+    _setRatioTo(995_000_000);
+    int256 belowBuffer = _attackerNetAtShare(90, donation);
+    vm.revertToState(snap);
+
+    console.log("at the 100.5% surplus buffer:");
+    _log(atBuffer);
+    console.log("one point below it:");
+    _log(belowBuffer);
+
+    assertLt(atBuffer, int256(0), "the attack must not pay at the surplus buffer");
+  }
+
   function _log(int256 net) internal pure {
     if (net > 0) console.log("    attacker GAINS", uint256(net));
     else console.log("    attacker LOSES", uint256(-net));

From 3e7d93a8e17fedd5267006f4bc69525ce70671f0 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 28 Sep 2026 11:11:21 +0300
Subject: [PATCH 26/38] test(redemption): measure the donation attack across
 the monthly surplus cycle

processSurplus runs monthly, so the ratio sawtooths between the buffer and
whatever yield adds before the next run. The trough is the block the run lands
in, which is both the thinnest and the most predictable moment.

Both ends of the cycle stay loss-making, and by almost the same margin: above
100% the curve is capped, so extra headroom buys nothing. That is the cap doing
the work rather than the size of the buffer.
---
 contracts/helpers/BaseRebalancer.sol          |  4 +-
 contracts/helpers/MultiBlockRebalancer.sol    |  1 -
 .../parallelizer/libraries/LibOracle.sol      |  7 ++--
 .../units/DonationRedemptionCoefficient.t.sol | 37 +++++++++++++++----
 tests/units/Rebalancer.t.sol                  |  1 -
 5 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/contracts/helpers/BaseRebalancer.sol b/contracts/helpers/BaseRebalancer.sol
index e313579..37300a5 100644
--- a/contracts/helpers/BaseRebalancer.sol
+++ b/contracts/helpers/BaseRebalancer.sol
@@ -283,9 +283,7 @@ abstract contract BaseRebalancer is IRebalancer, AccessManaged {
     }
   }
 
-  /// @notice Revokes the allowances a derived rebalancer granted over an asset being rotated out
-  /// @dev `_setYieldBearingAssetData` only clears the `asset -> yieldBearingAsset` approval the vault path uses.
-  /// A rebalancer that approves a different spender overrides this to clear its own relationship
+  /// @notice Lets a rebalancer revoke the allowances it granted over an asset being rotated out
   function _revokeAssetAllowances(address yieldBearingAsset, address previousAsset) internal virtual { }
 
   function _updateLimitExposuresYieldAsset(
diff --git a/contracts/helpers/MultiBlockRebalancer.sol b/contracts/helpers/MultiBlockRebalancer.sol
index 421b28a..6b293a9 100644
--- a/contracts/helpers/MultiBlockRebalancer.sol
+++ b/contracts/helpers/MultiBlockRebalancer.sol
@@ -63,7 +63,6 @@ contract MultiBlockRebalancer is BaseRebalancer {
   }
 
   /// @inheritdoc BaseRebalancer
-  /// @dev The deposit path approves `asset -> depositAddress`, so rotating the asset has to clear that too
   function _revokeAssetAllowances(address yieldBearingAsset, address previousAsset) internal override {
     address depositAddress = yieldBearingToDepositAddress[yieldBearingAsset];
     if (depositAddress != address(0)) {
diff --git a/contracts/parallelizer/libraries/LibOracle.sol b/contracts/parallelizer/libraries/LibOracle.sol
index c400e70..db45436 100644
--- a/contracts/parallelizer/libraries/LibOracle.sol
+++ b/contracts/parallelizer/libraries/LibOracle.sol
@@ -241,9 +241,8 @@ library LibOracle {
     return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));
   }
 
-  /// @notice Seeds the MAX target with the current spot, for a collateral that has never been ratcheted
-  /// @dev `updateOracle` bounds every step to `MAX_ORACLE_RATCHET_STEP` against the stored target, so a target
-  /// left at 0 can never be raised. Deployment goes through here once, then the ratchet takes over
+  /// @notice Seeds the MAX target with the current spot at deployment
+  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised
   function initializeOracleTarget(address collateral) internal {
     ParallelizerStorage storage ts = s.transmuterStorage();
     if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();
@@ -257,7 +256,7 @@ library LibOracle {
     ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);
 
     if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();
-    // Only an unset target may be seeded, so this cannot be used to sidestep the ratchet later on
+    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on
     if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();
 
     uint256 oracleValue = read(oracleType, BASE_18, oracleData);
diff --git a/tests/units/DonationRedemptionCoefficient.t.sol b/tests/units/DonationRedemptionCoefficient.t.sol
index 49704ba..f2f1687 100644
--- a/tests/units/DonationRedemptionCoefficient.t.sol
+++ b/tests/units/DonationRedemptionCoefficient.t.sol
@@ -230,10 +230,8 @@ contract Test_DonationRedemptionCoefficient is Fixture {
     }
   }
 
-  /// @dev Bailsec's residual case needs the system to be undercollateralised. Once the ratio reaches
-  /// 100% the curve sits at its cap, the donation buys no coefficient lift, and the attacker is left
-  /// paying the spread on the collateral they donated. The defence is the 100% kink rather than the
-  /// slope: widening the ramp barely moves the break-even, which sits just under 100% either way
+  /// @dev At or above 100% the curve sits at its cap, so the donation buys no coefficient lift and the
+  /// attacker is left paying the spread. The cap is what closes this, not the slope of the ramp
   function test_Overcollateralized_RemovesTheDonationProfit() public {
     uint256 donation = 2000e12;
 
@@ -255,9 +253,8 @@ contract Test_DonationRedemptionCoefficient is Fixture {
     assertLt(over, int256(0), "an overcollateralised system must not pay the donation attack");
   }
 
-  /// @dev `processSurplus` drives the ratio down to `surplusBufferRatio`, 100.5% on mainnet, so the
-  /// margin over the profitable region is under a point rather than the headroom a fresh reading
-  /// suggests. This pins where the donation attack turns positive from that steady state
+  /// @dev `processSurplus` drives the ratio down to `surplusBufferRatio`, so the margin over the
+  /// profitable region is under a point rather than whatever a spot reading suggests
   function test_SurplusBufferSteadyState_LeavesAThinMargin() public {
     uint256 donation = 2000e12;
 
@@ -281,6 +278,32 @@ contract Test_DonationRedemptionCoefficient is Fixture {
     assertLt(atBuffer, int256(0), "the attack must not pay at the surplus buffer");
   }
 
+  /// @dev The ratio sawtooths between the buffer and whatever yield adds before the next run, so the
+  /// trough is the block the run lands in
+  function test_MonthlySawtooth_TroughIsTheExposedPoint() public {
+    uint256 donation = 2000e12;
+
+    uint256 snap = vm.snapshotState();
+    _setRampedCurve(600_000_000);
+    _setRatioTo(1_005_000_000);
+    int256 trough = _attackerNetAtShare(90, donation);
+    vm.revertToState(snap);
+
+    snap = vm.snapshotState();
+    _setRampedCurve(600_000_000);
+    _setRatioTo(1_011_000_000);
+    int256 lateCycle = _attackerNetAtShare(90, donation);
+    vm.revertToState(snap);
+
+    console.log("trough, just after processSurplus:");
+    _log(trough);
+    console.log("late in the cycle, after a month of yield:");
+    _log(lateCycle);
+
+    assertLt(trough, int256(0), "the trough must still not pay the attack");
+    assertLt(lateCycle, int256(0), "later in the cycle must not pay either");
+  }
+
   function _log(int256 net) internal pure {
     if (net > 0) console.log("    attacker GAINS", uint256(net));
     else console.log("    attacker LOSES", uint256(-net));
diff --git a/tests/units/Rebalancer.t.sol b/tests/units/Rebalancer.t.sol
index cef902b..61a94a9 100644
--- a/tests/units/Rebalancer.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -180,7 +180,6 @@ contract Test_Rebalancer_Allowances is Fixture {
   function test_RotatingTheAsset_RevokesTheDepositAddressAllowance() public {
     vm.prank(governor);
     rebalancer.setYieldBearingToDepositAddress(address(eurY), bob);
-    // The deposit path approves the underlying to the deposit address, not to the yield bearing asset
     _seedAllowance(address(eurA), bob);
 
     vm.prank(guardian);

From 038164ed967011547ba050652ec8b76c21a49115 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 28 Sep 2026 13:47:26 +0300
Subject: [PATCH 27/38] style(tests): wrap the rebalancer constructor calls
 over the line limit

solhint caps lines at 120 and the two GenericRebalancer constructions ran to 122,
which failed the lint job and skipped the test jobs behind it.
---
 tests/units/Rebalancer.t.sol | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/tests/units/Rebalancer.t.sol b/tests/units/Rebalancer.t.sol
index 61a94a9..e7dbf19 100644
--- a/tests/units/Rebalancer.t.sol
+++ b/tests/units/Rebalancer.t.sol
@@ -72,7 +72,12 @@ contract Test_Rebalancer_ResidualInput is Fixture {
     router = new MockRouter();
     lender = new MockFlashLoan();
     rebalancer = new GenericRebalancer(
-      address(router), address(router), tokenP, parallelizer, address(accessManager), IERC3156FlashLender(address(lender))
+      address(router),
+      address(router),
+      tokenP,
+      parallelizer,
+      address(accessManager),
+      IERC3156FlashLender(address(lender))
     );
 
     vm.startPrank(governor);
@@ -227,7 +232,12 @@ contract Test_Rebalancer_FlashLoanFee is Fixture {
     router = new MockRouter();
     lender = new MockFlashLoan();
     rebalancer = new GenericRebalancer(
-      address(router), address(router), tokenP, parallelizer, address(accessManager), IERC3156FlashLender(address(lender))
+      address(router),
+      address(router),
+      tokenP,
+      parallelizer,
+      address(accessManager),
+      IERC3156FlashLender(address(lender))
     );
 
     vm.startPrank(governor);

From 518cb9141cf8c51c8d933bae0147e00416d218a6 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Mon, 28 Sep 2026 13:51:12 +0300
Subject: [PATCH 28/38] style(docs): realign the README tables after the
 rebalancer rename

Shortening the facet names left the markdown columns unaligned, which failed the
prettier check in the lint job.
---
 README.md | 120 +++++++++++++++++++++++++++---------------------------
 1 file changed, 60 insertions(+), 60 deletions(-)

diff --git a/README.md b/README.md
index 6356c98..40892dc 100644
--- a/README.md
+++ b/README.md
@@ -61,82 +61,82 @@ Some changed has been made to the original Angle's Transmuter:
 
 ### Mainnet
 
-| Contract              | Explore                                                                                                                |
-| --------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| DiamondCut Facet      | [0xad58Fc13a682a121e5fe2f8E45D4D988A7e51B0D](https:///etherscan.io/address/0xad58Fc13a682a121e5fe2f8E45D4D988A7e51B0D) |
-| DiamondLoupe Facet    | [0xA360E5aD9F17caff53715346888aA0d13541c2F5](https:///etherscan.io/address/0xA360E5aD9F17caff53715346888aA0d13541c2F5) |
-| Getters Facet         | [0xa9C21Cf291ad935e0C9B05a55A42254fB159181d](https:///etherscan.io/address/0xa9C21Cf291ad935e0C9B05a55A42254fB159181d) |
-| Redeemer Facet        | [0x1bB46FC55E3fd91Ca0F162DCC0B3ef574C8ff97E](https:///etherscan.io/address/0x1bB46FC55E3fd91Ca0F162DCC0B3ef574C8ff97E) |
-| RewardHandler Facet   | [0xd8cc2A51556Da84b5DB309e86f30Ff98B5309862](https:///etherscan.io/address/0xd8cc2A51556Da84b5DB309e86f30Ff98B5309862) |
-| SettersGovernor Facet | [0xeB197439D1425F3129F01F7763EC511DF2489095](https:///etherscan.io/address/0xeB197439D1425F3129F01F7763EC511DF2489095) |
-| SettersGuardian Facet | [0xc743BeDE8412228B42Ae755cD64A33Cd3ae4A92f](https:///etherscan.io/address/0xc743BeDE8412228B42Ae755cD64A33Cd3ae4A92f) |
-| Swapper Facet         | [0x506Ba37aa8e265bE445913B9c4080852277f3c5a](https:///etherscan.io/address/0x506Ba37aa8e265bE445913B9c4080852277f3c5a) |
-| Parallelizer USDp     | [0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2](https:///etherscan.io/address/0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2) |
-| sUSDp (Savings)       | [0x0d45b129dc868963025Db79A9074EA9c9e32Cae4](https:///etherscan.io/address/0x0d45b129dc868963025Db79A9074EA9c9e32Cae4) |
+| Contract               | Explore                                                                                                                |
+| ---------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| DiamondCut Facet       | [0xad58Fc13a682a121e5fe2f8E45D4D988A7e51B0D](https:///etherscan.io/address/0xad58Fc13a682a121e5fe2f8E45D4D988A7e51B0D) |
+| DiamondLoupe Facet     | [0xA360E5aD9F17caff53715346888aA0d13541c2F5](https:///etherscan.io/address/0xA360E5aD9F17caff53715346888aA0d13541c2F5) |
+| Getters Facet          | [0xa9C21Cf291ad935e0C9B05a55A42254fB159181d](https:///etherscan.io/address/0xa9C21Cf291ad935e0C9B05a55A42254fB159181d) |
+| Redeemer Facet         | [0x1bB46FC55E3fd91Ca0F162DCC0B3ef574C8ff97E](https:///etherscan.io/address/0x1bB46FC55E3fd91Ca0F162DCC0B3ef574C8ff97E) |
+| RewardHandler Facet    | [0xd8cc2A51556Da84b5DB309e86f30Ff98B5309862](https:///etherscan.io/address/0xd8cc2A51556Da84b5DB309e86f30Ff98B5309862) |
+| SettersGovernor Facet  | [0xeB197439D1425F3129F01F7763EC511DF2489095](https:///etherscan.io/address/0xeB197439D1425F3129F01F7763EC511DF2489095) |
+| SettersGuardian Facet  | [0xc743BeDE8412228B42Ae755cD64A33Cd3ae4A92f](https:///etherscan.io/address/0xc743BeDE8412228B42Ae755cD64A33Cd3ae4A92f) |
+| Swapper Facet          | [0x506Ba37aa8e265bE445913B9c4080852277f3c5a](https:///etherscan.io/address/0x506Ba37aa8e265bE445913B9c4080852277f3c5a) |
+| Parallelizer USDp      | [0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2](https:///etherscan.io/address/0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2) |
+| sUSDp (Savings)        | [0x0d45b129dc868963025Db79A9074EA9c9e32Cae4](https:///etherscan.io/address/0x0d45b129dc868963025Db79A9074EA9c9e32Cae4) |
 | GenericRebalancer USDp | [0x36DA06796fD9d22BCD6287b66A87FfdadB12636C](https:///etherscan.io/address/0x36DA06796fD9d22BCD6287b66A87FfdadB12636C) |
 
 ### Base
 
-| Contract              | Explore                                                                                                                |
-| --------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| DiamondCut Facet      | [0x15452454A9735D68df430879B2941316a09295B1](https:///basescan.org/address/0x15452454A9735D68df430879B2941316a09295B1) |
-| DiamondLoupe Facet    | [0x24CeF236056834f38e9247A1Fff6681Dd313d3aa](https:///basescan.org/address/0x24CeF236056834f38e9247A1Fff6681Dd313d3aa) |
-| Getters Facet         | [0xBE65F0F410A72BeC163dC65d46c83699e957D588](https:///basescan.org/address/0xBE65F0F410A72BeC163dC65d46c83699e957D588) |
-| Redeemer Facet        | [0xe9fe4720FA99f9b28584dA44ABB8cf91f15990e8](https:///basescan.org/address/0xe9fe4720FA99f9b28584dA44ABB8cf91f15990e8) |
-| RewardHandler Facet   | [0x2B6C7c275404e93A14A05b549AF292231D6e4DeC](https:///basescan.org/address/0x2B6C7c275404e93A14A05b549AF292231D6e4DeC) |
-| SettersGovernor Facet | [0x90e4AE8bA8C6Fd51fcED0f9331668b05c7a4Ee43](https:///basescan.org/address/0x90e4AE8bA8C6Fd51fcED0f9331668b05c7a4Ee43) |
-| SettersGuardian Facet | [0xe5C82b4F09Fd4d079757e156Db44AFD2c8032CC8](https:///basescan.org/address/0xe5C82b4F09Fd4d079757e156Db44AFD2c8032CC8) |
-| Swapper Facet         | [0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7](https:///basescan.org/address/0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7) |
-| Parallelizer USDp     | [0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD](https:///basescan.org/address/0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD) |
-| sUSDp (Savings)       | [0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7](https:///basescan.org/address/0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7) |
+| Contract               | Explore                                                                                                                |
+| ---------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| DiamondCut Facet       | [0x15452454A9735D68df430879B2941316a09295B1](https:///basescan.org/address/0x15452454A9735D68df430879B2941316a09295B1) |
+| DiamondLoupe Facet     | [0x24CeF236056834f38e9247A1Fff6681Dd313d3aa](https:///basescan.org/address/0x24CeF236056834f38e9247A1Fff6681Dd313d3aa) |
+| Getters Facet          | [0xBE65F0F410A72BeC163dC65d46c83699e957D588](https:///basescan.org/address/0xBE65F0F410A72BeC163dC65d46c83699e957D588) |
+| Redeemer Facet         | [0xe9fe4720FA99f9b28584dA44ABB8cf91f15990e8](https:///basescan.org/address/0xe9fe4720FA99f9b28584dA44ABB8cf91f15990e8) |
+| RewardHandler Facet    | [0x2B6C7c275404e93A14A05b549AF292231D6e4DeC](https:///basescan.org/address/0x2B6C7c275404e93A14A05b549AF292231D6e4DeC) |
+| SettersGovernor Facet  | [0x90e4AE8bA8C6Fd51fcED0f9331668b05c7a4Ee43](https:///basescan.org/address/0x90e4AE8bA8C6Fd51fcED0f9331668b05c7a4Ee43) |
+| SettersGuardian Facet  | [0xe5C82b4F09Fd4d079757e156Db44AFD2c8032CC8](https:///basescan.org/address/0xe5C82b4F09Fd4d079757e156Db44AFD2c8032CC8) |
+| Swapper Facet          | [0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7](https:///basescan.org/address/0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7) |
+| Parallelizer USDp      | [0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD](https:///basescan.org/address/0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD) |
+| sUSDp (Savings)        | [0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7](https:///basescan.org/address/0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7) |
 | GenericRebalancer USDp | [0xCa43eCFCDFBA1fED003649e946Ae6091646B410a](https:///basescan.org/address/0xCa43eCFCDFBA1fED003649e946Ae6091646B410a) |
 
 ### Sonic
 
-| Contract              | Explore                                                                                                                 |
-| --------------------- | ----------------------------------------------------------------------------------------------------------------------- |
-| DiamondCut Facet      | [0xe9fe4720FA99f9b28584dA44ABB8cf91f15990e8](https:///sonicscan.org/address/0xe9fe4720FA99f9b28584dA44ABB8cf91f15990e8) |
-| DiamondLoupe Facet    | [0x2B6C7c275404e93A14A05b549AF292231D6e4DeC](https:///sonicscan.org/address/0x2B6C7c275404e93A14A05b549AF292231D6e4DeC) |
-| Getters Facet         | [0x90e4AE8bA8C6Fd51fcED0f9331668b05c7a4Ee43](https:///sonicscan.org/address/0x90e4AE8bA8C6Fd51fcED0f9331668b05c7a4Ee43) |
-| Redeemer Facet        | [0xe5C82b4F09Fd4d079757e156Db44AFD2c8032CC8](https:///sonicscan.org/address/0xe5C82b4F09Fd4d079757e156Db44AFD2c8032CC8) |
-| RewardHandler Facet   | [0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7](https:///sonicscan.org/address/0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7) |
-| SettersGovernor Facet | [0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD](https:///sonicscan.org/address/0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD) |
-| SettersGuardian Facet | [0xCa43eCFCDFBA1fED003649e946Ae6091646B410a](https:///sonicscan.org/address/0xCa43eCFCDFBA1fED003649e946Ae6091646B410a) |
-| Swapper Facet         | [0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF](https:///sonicscan.org/address/0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF) |
-| Parallelizer USDp     | [0xBEFBAe2330186F031b469e26283aCc66bb5F8826](https:///sonicscan.org/address/0xBEFBAe2330186F031b469e26283aCc66bb5F8826) |
-| sUSDp (Savings)       | [0xe8a3DA6f5ed1cf04c58ac7f6A7383641e877517b](https:///sonicscan.org/address/0xe8a3DA6f5ed1cf04c58ac7f6A7383641e877517b) |
+| Contract               | Explore                                                                                                                 |
+| ---------------------- | ----------------------------------------------------------------------------------------------------------------------- |
+| DiamondCut Facet       | [0xe9fe4720FA99f9b28584dA44ABB8cf91f15990e8](https:///sonicscan.org/address/0xe9fe4720FA99f9b28584dA44ABB8cf91f15990e8) |
+| DiamondLoupe Facet     | [0x2B6C7c275404e93A14A05b549AF292231D6e4DeC](https:///sonicscan.org/address/0x2B6C7c275404e93A14A05b549AF292231D6e4DeC) |
+| Getters Facet          | [0x90e4AE8bA8C6Fd51fcED0f9331668b05c7a4Ee43](https:///sonicscan.org/address/0x90e4AE8bA8C6Fd51fcED0f9331668b05c7a4Ee43) |
+| Redeemer Facet         | [0xe5C82b4F09Fd4d079757e156Db44AFD2c8032CC8](https:///sonicscan.org/address/0xe5C82b4F09Fd4d079757e156Db44AFD2c8032CC8) |
+| RewardHandler Facet    | [0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7](https:///sonicscan.org/address/0xfB2D070270e9FfC2dB107D0162b47c2Ed291E3F7) |
+| SettersGovernor Facet  | [0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD](https:///sonicscan.org/address/0xC3BEF21Ea7dEB5C34CF33E918c8e28972C8048eD) |
+| SettersGuardian Facet  | [0xCa43eCFCDFBA1fED003649e946Ae6091646B410a](https:///sonicscan.org/address/0xCa43eCFCDFBA1fED003649e946Ae6091646B410a) |
+| Swapper Facet          | [0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF](https:///sonicscan.org/address/0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF) |
+| Parallelizer USDp      | [0xBEFBAe2330186F031b469e26283aCc66bb5F8826](https:///sonicscan.org/address/0xBEFBAe2330186F031b469e26283aCc66bb5F8826) |
+| sUSDp (Savings)        | [0xe8a3DA6f5ed1cf04c58ac7f6A7383641e877517b](https:///sonicscan.org/address/0xe8a3DA6f5ed1cf04c58ac7f6A7383641e877517b) |
 | GenericRebalancer USDp | [0x120805265fA944834DC6e930De2995768806a9d2](https:///sonicscan.org/address/0x120805265fA944834DC6e930De2995768806a9d2) |
 
 #### HyperEVM
 
-| Contract              | Explore                                                                                                                     |
-| --------------------- | --------------------------------------------------------------------------------------------------------------------------- |
-| DiamondCut Facet      | [0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF](https:///www.hyperscan.com/address/0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF) |
-| DiamondLoupe Facet    | [0xBEFBAe2330186F031b469e26283aCc66bb5F8826](https:///www.hyperscan.com/address/0xBEFBAe2330186F031b469e26283aCc66bb5F8826) |
-| Getters Facet         | [0x120805265fA944834DC6e930De2995768806a9d2](https:///www.hyperscan.com/address/0x120805265fA944834DC6e930De2995768806a9d2) |
-| Redeemer Facet        | [0xF92eD96C7bEc4aD46FF7937Cae633c907EBDf594](https:///www.hyperscan.com/address/0xF92eD96C7bEc4aD46FF7937Cae633c907EBDf594) |
-| RewardHandler Facet   | [0xa5d9CAA2EF06D39d5992b5046e2DEFFf6D5Cbd18](https:///www.hyperscan.com/address/0xa5d9CAA2EF06D39d5992b5046e2DEFFf6D5Cbd18) |
-| SettersGovernor Facet | [0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7](https:///www.hyperscan.com/address/0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7) |
-| SettersGuardian Facet | [0xaE2Fb66d1989EC1684fF095B75D151Ae8E403E2e](https:///www.hyperscan.com/address/0xaE2Fb66d1989EC1684fF095B75D151Ae8E403E2e) |
-| Swapper Facet         | [0x1b2741dB9F46a0411852e4cC28dDC476851b5179](https:///www.hyperscan.com/address/0x1b2741dB9F46a0411852e4cC28dDC476851b5179) |
-| Parallelizer USDp     | [0x1250304F66404cd153fA39388DDCDAec7E0f1707](https:///www.hyperscan.com/address/0x1250304F66404cd153fA39388DDCDAec7E0f1707) |
-| sUSDp (Savings)       | [0x9B3a8f7CEC208e247d97dEE13313690977e24459](https:///www.hyperscan.com/address/0x9B3a8f7CEC208e247d97dEE13313690977e24459) |
+| Contract               | Explore                                                                                                                     |
+| ---------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| DiamondCut Facet       | [0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF](https:///www.hyperscan.com/address/0xA65821FfE86E6Eb613DAa1F70AF350C5A21759dF) |
+| DiamondLoupe Facet     | [0xBEFBAe2330186F031b469e26283aCc66bb5F8826](https:///www.hyperscan.com/address/0xBEFBAe2330186F031b469e26283aCc66bb5F8826) |
+| Getters Facet          | [0x120805265fA944834DC6e930De2995768806a9d2](https:///www.hyperscan.com/address/0x120805265fA944834DC6e930De2995768806a9d2) |
+| Redeemer Facet         | [0xF92eD96C7bEc4aD46FF7937Cae633c907EBDf594](https:///www.hyperscan.com/address/0xF92eD96C7bEc4aD46FF7937Cae633c907EBDf594) |
+| RewardHandler Facet    | [0xa5d9CAA2EF06D39d5992b5046e2DEFFf6D5Cbd18](https:///www.hyperscan.com/address/0xa5d9CAA2EF06D39d5992b5046e2DEFFf6D5Cbd18) |
+| SettersGovernor Facet  | [0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7](https:///www.hyperscan.com/address/0x472eD57b376fE400259FB28e5C46eB53f0E3e7E7) |
+| SettersGuardian Facet  | [0xaE2Fb66d1989EC1684fF095B75D151Ae8E403E2e](https:///www.hyperscan.com/address/0xaE2Fb66d1989EC1684fF095B75D151Ae8E403E2e) |
+| Swapper Facet          | [0x1b2741dB9F46a0411852e4cC28dDC476851b5179](https:///www.hyperscan.com/address/0x1b2741dB9F46a0411852e4cC28dDC476851b5179) |
+| Parallelizer USDp      | [0x1250304F66404cd153fA39388DDCDAec7E0f1707](https:///www.hyperscan.com/address/0x1250304F66404cd153fA39388DDCDAec7E0f1707) |
+| sUSDp (Savings)        | [0x9B3a8f7CEC208e247d97dEE13313690977e24459](https:///www.hyperscan.com/address/0x9B3a8f7CEC208e247d97dEE13313690977e24459) |
 | GenericRebalancer USDp | [0x57770C1721Eb35509f38210A935c8b1911db7E0e](https:///www.hyperscan.com/address/0x57770C1721Eb35509f38210A935c8b1911db7E0e) |
 
 #### Avalanche
 
-| Contract              | Explore                                                                                                                    |
-| --------------------- | -------------------------------------------------------------------------------------------------------------------------- |
-| DiamondCut Facet      | [0x657acB8A3BF9383e561565d422ea9b9A90ce0052](https:///www.snowscan.xyz/address/0x657acB8A3BF9383e561565d422ea9b9A90ce0052) |
-| DiamondLoupe Facet    | [0x23D491aa7C0972087F8a607F6f4c7106a02BA95d](https:///www.snowscan.xyz/address/0x23D491aa7C0972087F8a607F6f4c7106a02BA95d) |
-| Getters Facet         | [0xF6Cc47E981ED5902BE382dbe7B54e3696De22dBb](https:///www.snowscan.xyz/address/0xF6Cc47E981ED5902BE382dbe7B54e3696De22dBb) |
-| Redeemer Facet        | [0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2](https:///www.snowscan.xyz/address/0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2) |
-| RewardHandler Facet   | [0x36DA06796fD9d22BCD6287b66A87FfdadB12636C](https:///www.snowscan.xyz/address/0x36DA06796fD9d22BCD6287b66A87FfdadB12636C) |
-| SettersGovernor Facet | [0x5bEADA21a6B9Cb229117B3EA2C0D1594785013A2](https:///www.snowscan.xyz/address/0x5bEADA21a6B9Cb229117B3EA2C0D1594785013A2) |
-| SettersGuardian Facet | [0xbBC90E685C4a66EBBDC71a3A1437d3111e43Fe84](https:///www.snowscan.xyz/address/0xbBC90E685C4a66EBBDC71a3A1437d3111e43Fe84) |
-| Swapper Facet         | [0x57265a3D7db8f4a4a155eadF6c7326926caC1490](https:///www.snowscan.xyz/address/0x57265a3D7db8f4a4a155eadF6c7326926caC1490) |
-| Parallelizer USDp     | [0x41d58951cbd12D4Ef49b0437897677bbF5547C80](https:///www.snowscan.xyz/address/0x41d58951cbd12D4Ef49b0437897677bbF5547C80) |
-| sUSDp (Savings)       | [0x9d92c21205383651610f90722131655a5b8ed3e0](https:///www.snowscan.xyz/address/0x9d92c21205383651610f90722131655a5b8ed3e0) |
+| Contract               | Explore                                                                                                                    |
+| ---------------------- | -------------------------------------------------------------------------------------------------------------------------- |
+| DiamondCut Facet       | [0x657acB8A3BF9383e561565d422ea9b9A90ce0052](https:///www.snowscan.xyz/address/0x657acB8A3BF9383e561565d422ea9b9A90ce0052) |
+| DiamondLoupe Facet     | [0x23D491aa7C0972087F8a607F6f4c7106a02BA95d](https:///www.snowscan.xyz/address/0x23D491aa7C0972087F8a607F6f4c7106a02BA95d) |
+| Getters Facet          | [0xF6Cc47E981ED5902BE382dbe7B54e3696De22dBb](https:///www.snowscan.xyz/address/0xF6Cc47E981ED5902BE382dbe7B54e3696De22dBb) |
+| Redeemer Facet         | [0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2](https:///www.snowscan.xyz/address/0x6efeDDF9269c3683Ba516cb0e2124FE335F262a2) |
+| RewardHandler Facet    | [0x36DA06796fD9d22BCD6287b66A87FfdadB12636C](https:///www.snowscan.xyz/address/0x36DA06796fD9d22BCD6287b66A87FfdadB12636C) |
+| SettersGovernor Facet  | [0x5bEADA21a6B9Cb229117B3EA2C0D1594785013A2](https:///www.snowscan.xyz/address/0x5bEADA21a6B9Cb229117B3EA2C0D1594785013A2) |
+| SettersGuardian Facet  | [0xbBC90E685C4a66EBBDC71a3A1437d3111e43Fe84](https:///www.snowscan.xyz/address/0xbBC90E685C4a66EBBDC71a3A1437d3111e43Fe84) |
+| Swapper Facet          | [0x57265a3D7db8f4a4a155eadF6c7326926caC1490](https:///www.snowscan.xyz/address/0x57265a3D7db8f4a4a155eadF6c7326926caC1490) |
+| Parallelizer USDp      | [0x41d58951cbd12D4Ef49b0437897677bbF5547C80](https:///www.snowscan.xyz/address/0x41d58951cbd12D4Ef49b0437897677bbF5547C80) |
+| sUSDp (Savings)        | [0x9d92c21205383651610f90722131655a5b8ed3e0](https:///www.snowscan.xyz/address/0x9d92c21205383651610f90722131655a5b8ed3e0) |
 | GenericRebalancer USDp | [0x0d45b129dc868963025db79a9074ea9c9e32cae4](https:///www.snowscan.xyz/address/0x0d45b129dc868963025db79a9074ea9c9e32cae4) |
 
 ### Testnet

From e228e328bb7e9f1357e462841e98d022a3f04228 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Thu, 8 Oct 2026 11:50:59 +0300
Subject: [PATCH 29/38] chore(deployments): record the avalanche facets upgrade
 and GenericRebalancer

SettersGovernor, Getters, Redeemer and RewardHandler are redeployed, and the
GenericRebalancer is deployed behind the team CooperAccessManager.
---
 .../avalanche/GenericRebalancer_USDp.json     | 1228 +++++++++++++++++
 deployments/avalanche/Getters.json            |   46 +-
 deployments/avalanche/Redeemer.json           |   71 +-
 deployments/avalanche/RewardHandler.json      |   33 +-
 deployments/avalanche/SettersGovernor.json    |   97 +-
 5 files changed, 1408 insertions(+), 67 deletions(-)
 create mode 100644 deployments/avalanche/GenericRebalancer_USDp.json

diff --git a/deployments/avalanche/GenericRebalancer_USDp.json b/deployments/avalanche/GenericRebalancer_USDp.json
new file mode 100644
index 0000000..af5764a
--- /dev/null
+++ b/deployments/avalanche/GenericRebalancer_USDp.json
@@ -0,0 +1,1228 @@
+{
+  "address": "0xb5a980349434a46687f425075f5558cd185ab9fa",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "initialTokenTransferAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "initialSwapRouter",
+          "type": "address"
+        },
+        {
+          "internalType": "contract ITokenP",
+          "name": "definitivetokenP",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IParallelizer",
+          "name": "definitiveParallelizer",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "initialAuthority",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC3156FlashLender",
+          "name": "definitiveFlashloan",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "authority",
+          "type": "address"
+        }
+      ],
+      "name": "AccessManagedInvalidAuthority",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        },
+        {
+          "internalType": "uint32",
+          "name": "delay",
+          "type": "uint32"
+        }
+      ],
+      "name": "AccessManagedRequiredDelay",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        }
+      ],
+      "name": "AccessManagedUnauthorized",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "InvalidParam",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "NotTrusted",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "NotTrustedOrGuardian",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        }
+      ],
+      "name": "SafeERC20FailedOperation",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "SwapError",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "ZeroAmount",
+      "type": "error"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "AllowanceReset",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "authority",
+          "type": "address"
+        }
+      ],
+      "name": "AuthorityUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "Recovered",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newSwapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "SwapRouterUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newTokenTransferAddress",
+          "type": "address"
+        }
+      ],
+      "name": "TokenTransferAddressUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "trusted",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "bool",
+          "name": "status",
+          "type": "bool"
+        }
+      ],
+      "name": "TrustedToggled",
+      "type": "event"
+    },
+    {
+      "inputs": [],
+      "name": "CALLBACK_SUCCESS",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "addBudget",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "authority",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "budget",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        }
+      ],
+      "name": "computeRebalanceAmount",
+      "outputs": [
+        {
+          "internalType": "uint8",
+          "name": "increase",
+          "type": "uint8"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "flashloan",
+      "outputs": [
+        {
+          "internalType": "contract IERC3156FlashLender",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "scale",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "extraData",
+          "type": "bytes"
+        }
+      ],
+      "name": "harvest",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isConsumingScheduledOp",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "",
+          "type": "bytes4"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "isTrusted",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "initiator",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "fee",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        }
+      ],
+      "name": "onFlashLoan",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "parallelizer",
+      "outputs": [
+        {
+          "internalType": "contract IParallelizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountToRecover",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "recoverERC20",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "removeBudget",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "resetAllowance",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newAuthority",
+          "type": "address"
+        }
+      ],
+      "name": "setAuthority",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "newMaxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "name": "setMaxSlippage",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newSwapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "setSwapRouter",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        }
+      ],
+      "name": "setTargetExposure",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newTokenTransferAddress",
+          "type": "address"
+        }
+      ],
+      "name": "setTokenTransferAddress",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "asset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "minExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "overrideExposures",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "name": "setYieldBearingAssetData",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "swapRouter",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "trusted",
+          "type": "address"
+        }
+      ],
+      "name": "toggleTrusted",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "tokenP",
+      "outputs": [
+        {
+          "internalType": "contract ITokenP",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "tokenTransferAddress",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        }
+      ],
+      "name": "updateLimitExposuresYieldAsset",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "yieldBearingData",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "asset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "minExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "overrideExposures",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "contractName": "GenericRebalancer",
+  "sourceName": "contracts/helpers/GenericRebalancer.sol",
+  "bytecode": "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",
+  "deployedBytecode": "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",
+  "linkReferences": {},
+  "deployedLinkReferences": {},
+  "immutableReferences": {
+    "10252": [
+      {
+        "length": 32,
+        "start": 629
+      },
+      {
+        "length": 32,
+        "start": 1913
+      },
+      {
+        "length": 32,
+        "start": 2055
+      },
+      {
+        "length": 32,
+        "start": 2191
+      },
+      {
+        "length": 32,
+        "start": 4217
+      },
+      {
+        "length": 32,
+        "start": 5920
+      },
+      {
+        "length": 32,
+        "start": 6053
+      },
+      {
+        "length": 32,
+        "start": 6348
+      },
+      {
+        "length": 32,
+        "start": 6493
+      },
+      {
+        "length": 32,
+        "start": 7129
+      },
+      {
+        "length": 32,
+        "start": 7419
+      }
+    ],
+    "10256": [
+      {
+        "length": 32,
+        "start": 470
+      },
+      {
+        "length": 32,
+        "start": 1497
+      },
+      {
+        "length": 32,
+        "start": 1849
+      },
+      {
+        "length": 32,
+        "start": 2137
+      },
+      {
+        "length": 32,
+        "start": 3715
+      },
+      {
+        "length": 32,
+        "start": 6001
+      },
+      {
+        "length": 32,
+        "start": 8074
+      }
+    ],
+    "11053": [
+      {
+        "length": 32,
+        "start": 538
+      },
+      {
+        "length": 32,
+        "start": 1553
+      },
+      {
+        "length": 32,
+        "start": 8026
+      }
+    ]
+  },
+  "inputSourceName": "project/contracts/helpers/GenericRebalancer.sol",
+  "devdoc": {
+    "author": "Cooper Labs",
+    "custom:contact": "security@cooperlabs.xyz",
+    "details": "Generic contract for trusted callers to adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract, substantially modified: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
+    "errors": {
+      "SafeERC20FailedOperation(address)": [
+        {
+          "details": "An operation with an ERC-20 token failed."
+        }
+      ]
+    },
+    "events": {
+      "AuthorityUpdated(address)": {
+        "details": "Authority that manages this contract was updated."
+      }
+    },
+    "kind": "dev",
+    "methods": {
+      "addBudget(uint256,address)": {
+        "params": {
+          "amount": "amount of tokenP to add to the budget",
+          "receiver": "address of the receiver"
+        }
+      },
+      "authority()": {
+        "details": "Returns the current authority."
+      },
+      "computeRebalanceAmount(address)": {
+        "params": {
+          "yieldBearingAsset": "address of the yield bearing asset"
+        },
+        "returns": {
+          "amount": "amount to be rebalanced",
+          "increase": "whether the exposure should be increased"
+        }
+      },
+      "harvest(address,uint256,bytes)": {
+        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippageRestricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the collateral oracle, neither of which can be safely exposed to arbitrary callers"
+      },
+      "isConsumingScheduledOp()": {
+        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
+      },
+      "onFlashLoan(address,address,uint256,uint256,bytes)": {
+        "details": "A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any shortfall between the principal and the tokenP the rebalance minted back",
+        "params": {
+          "amount": "The amount of tokens lent.",
+          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
+          "fee": "The additional amount of tokens to repay.",
+          "initiator": "The initiator of the loan.",
+          "token": "The loan currency."
+        },
+        "returns": {
+          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
+        }
+      },
+      "recoverERC20(address,uint256,address)": {
+        "params": {
+          "amountToRecover": "amount to recover",
+          "to": "address to send the recovered tokens",
+          "tokenAddress": "address of the token to recover"
+        }
+      },
+      "removeBudget(uint256,address)": {
+        "params": {
+          "amount": "amount of tokenP to remove from the budget",
+          "receiver": "address of the receiver"
+        }
+      },
+      "resetAllowance(address,address)": {
+        "details": "Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing asset's configuration revokes the approvals it created, but this covers a spender that became untrusted for any other reason.",
+        "params": {
+          "spender": "address losing the allowance",
+          "token": "address of the token"
+        }
+      },
+      "setAuthority(address)": {
+        "details": "Transfers control to a new authority. The caller must be the current authority."
+      },
+      "setMaxSlippage(address,uint64)": {
+        "params": {
+          "newMaxSlippage": "new max allowed slippage"
+        }
+      },
+      "setSwapRouter(address)": {
+        "params": {
+          "newSwapRouter": "address of the swap router"
+        }
+      },
+      "setTargetExposure(address,uint64)": {
+        "params": {
+          "targetExposure": "target exposure to the yield bearing asset used",
+          "yieldBearingAsset": "address of the yield bearing asset"
+        }
+      },
+      "setTokenTransferAddress(address)": {
+        "params": {
+          "newTokenTransferAddress": "address of the token transfer contract"
+        }
+      },
+      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": {
+        "params": {
+          "asset": "address of the asset",
+          "maxExposure": "maximum exposure within the Parallelizer to the asset",
+          "minExposure": "minimum exposure within the Parallelizer to the asset",
+          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
+          "targetExposure": "target exposure to the yieldBearingAsset asset used",
+          "yieldBearingAsset": "address of the yieldBearingAsset"
+        }
+      },
+      "toggleTrusted(address)": {
+        "params": {
+          "trusted": "address to toggle the trusted status"
+        }
+      },
+      "updateLimitExposuresYieldAsset(address)": {
+        "params": {
+          "yieldBearingAsset": "address of the yield bearing asset"
+        }
+      }
+    },
+    "title": "GenericRebalancer",
+    "version": 1
+  },
+  "evm": {
+    "gasEstimates": {
+      "creation": {
+        "codeDepositCost": "2436200",
+        "executionCost": "infinite",
+        "totalCost": "infinite"
+      },
+      "external": {
+        "CALLBACK_SUCCESS()": "240",
+        "addBudget(uint256,address)": "infinite",
+        "authority()": "2407",
+        "budget(address)": "2554",
+        "computeRebalanceAmount(address)": "infinite",
+        "flashloan()": "infinite",
+        "harvest(address,uint256,bytes)": "infinite",
+        "isConsumingScheduledOp()": "2442",
+        "isTrusted(address)": "2612",
+        "onFlashLoan(address,address,uint256,uint256,bytes)": "infinite",
+        "parallelizer()": "infinite",
+        "recoverERC20(address,uint256,address)": "infinite",
+        "removeBudget(uint256,address)": "infinite",
+        "resetAllowance(address,address)": "infinite",
+        "setAuthority(address)": "30486",
+        "setMaxSlippage(address,uint64)": "infinite",
+        "setSwapRouter(address)": "infinite",
+        "setTargetExposure(address,uint64)": "infinite",
+        "setTokenTransferAddress(address)": "infinite",
+        "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": "infinite",
+        "swapRouter()": "2392",
+        "toggleTrusted(address)": "infinite",
+        "tokenP()": "infinite",
+        "tokenTransferAddress()": "2415",
+        "updateLimitExposuresYieldAsset(address)": "infinite",
+        "yieldBearingData(address)": "5001"
+      },
+      "internal": {
+        "_adjustYieldExposure(uint256,uint8,address,address,uint256,enum SwapType,bytes memory)": "infinite",
+        "_recoverResidualInput(address,uint256)": "infinite",
+        "_swapToTokenOut(uint256,address,address,uint256,enum SwapType,bytes memory)": "infinite",
+        "_swapToTokenOutSwap(address,address,uint256,bytes memory)": "infinite",
+        "_swapToTokenOutVault(uint256,address,address,uint256)": "infinite"
+      }
+    }
+  },
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"AllowanceReset\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"resetAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newMaxSlippage\",\"type\":\"uint64\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxSlippage\",\"type\":\"uint64\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxSlippage\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for trusted callers to adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract, substantially modified: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippageRestricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the collateral oracle, neither of which can be safely exposed to arbitrary callers\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any shortfall between the principal and the tokenP the rebalance minted back\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"resetAllowance(address,address)\":{\"details\":\"Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing asset's configuration revokes the approvals it created, but this covers a spender that became untrusted for any other reason.\",\"params\":{\"spender\":\"address losing the allowance\",\"token\":\"address of the token\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint64)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericRebalancer\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"resetAllowance(address,address)\":{\"notice\":\"Set an allowance this contract granted back to zero\"},\"setMaxSlippage(address,uint64)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/helpers/GenericRebalancer.sol\":\"GenericRebalancer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0x1121e070554cffc6d536f658332a1a3d65fb2ea5573cd774f4ecbd02a2fcf4b7\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x4e4b982b56b50290dd1dcaa2fef1178b1574dfc7c0f0a8ef9cb68a207d72582e\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity >=0.5.0;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x218d708e7d8df417db24a497727eefb7772e61c7cde3886fc42bbcb6aafa6947\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/helpers/BaseRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IRebalancer.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer, bounded below 1e9 so uint64 leaves the\\n  // struct packed in two slots\\n  uint64 maxSlippage;\\n}\\n\\n/// @title BaseRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a rebalancer that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract, substantially modified:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseRebalancer is IRebalancer, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n  event AllowanceReset(address indexed token, address indexed spender);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /**\\n   * @notice Set an allowance this contract granted back to zero\\n   * @param token address of the token\\n   * @param spender address losing the allowance\\n   * @dev Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing\\n   * asset's configuration revokes the approvals it created, but this covers a spender that became\\n   * untrusted for any other reason.\\n   */\\n  function resetAllowance(address token, address spender) external restricted {\\n    IERC20(token).forceApprove(spender, 0);\\n    emit AllowanceReset(token, spender);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    address previousAsset = yieldBearingInfo.asset;\\n    // Allowances are granted without expiry, so the outgoing asset would keep the yield bearing\\n    // vault authorised over any of it later held here\\n    if (previousAsset != address(0) && previousAsset != asset) {\\n      IERC20(previousAsset).forceApprove(yieldBearingAsset, 0);\\n      emit AllowanceReset(previousAsset, yieldBearingAsset);\\n      _revokeAssetAllowances(yieldBearingAsset, previousAsset);\\n    }\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /// @notice Lets a rebalancer revoke the allowances it granted over an asset being rotated out\\n  function _revokeAssetAllowances(address yieldBearingAsset, address previousAsset) internal virtual { }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingData[yieldBearingAsset].maxSlippage = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x5d05479be1ac7d1dc738cb8fc2e539c82e88a2191dee278cc74fd647eed17ebc\",\"license\":\"GPL-3.0\"},\"project/contracts/helpers/GenericRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseRebalancer, YieldBearingParams } from \\\"./BaseRebalancer.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for trusted callers to adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract, substantially modified:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseRebalancer(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  /// @dev Restricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the\\n  /// collateral oracle, neither of which can be safely exposed to arbitrary callers\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual onlyTrusted {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  /// @dev A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any\\n  /// shortfall between the principal and the tokenP the rebalance minted back\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this)) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 tokenInBalanceBefore = IERC20(tokenIn).balanceOf(address(this));\\n\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n    // The principal is spent, what the lender will pull back is the principal plus its fee\\n    amount += fee;\\n\\n    // Swap to tokenOut\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n\\n    amountStableOut += _recoverResidualInput(tokenIn, tokenInBalanceBefore);\\n\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    } else if (amountStableOut > amount) {\\n      budget[sender] += amountStableOut - amount;\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  /**\\n   * @dev Returns any input the route did not consume to the Parallelizer\\n   * @param tokenIn address of the token offered to the route\\n   * @param balanceBefore balance of `tokenIn` held before the operation\\n   * @return the tokenP obtained from the remainder, zero when the route consumed everything\\n   *\\n   * Router calldata is built off chain while the input is sized on chain, so a route can consume\\n   * less than was offered. Returning the remainder keeps it inside the Parallelizer's accounting\\n   * instead of stranding it here, and it settles with the rest of the operation.\\n   */\\n  function _recoverResidualInput(address tokenIn, uint256 balanceBefore) internal returns (uint256) {\\n    uint256 balanceAfter = IERC20(tokenIn).balanceOf(address(this));\\n    if (balanceAfter <= balanceBefore) return 0;\\n    uint256 residual = balanceAfter - balanceBefore;\\n    _adjustAllowance(tokenIn, address(parallelizer), residual);\\n    return parallelizer.swapExactInput(residual, 0, tokenIn, address(tokenP), address(this), block.timestamp);\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n    // A route that consumed less than offered would otherwise leave the difference approved\\n    IERC20(tokenIn).forceApprove(tokenTransferAddress, 0);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0xe10b65b2a75ead0d938a2282cf478e94ea425adb38a03ca077fa0422ec2d322c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  function getSwapRouter() external view returns (address);\\n\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x27a333b02ba124b5964a63bddeb301328197bddbe98538903cd41a8b40900d12\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\nimport { ISurplus } from \\\"./ISurplus.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuter` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuter.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper,\\n  ISurplus\\n{ }\\n\",\"keccak256\":\"0x3d43efebf663185429a411300477c3a62bf5e025fb286cf812cd0b589fb8bd5a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IRebalancer {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0a30a492e29ebe67db0f4cac7bfb142d04556a61282e71733d13c11daeba08b1\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was\\n  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since\\n  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`\\n  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity\\n  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x3362bd4532915b6e2b26b2fdc967a89ea66de5ea5f669d7a621ee69d75c02273\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a call to the configured swap router\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to the swap router\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xb3604f35c5bb44791020588e00774299a6a4adae17d62d1e53cd8be86da6b709\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n\\n  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain\\n  /// specific and must be set on every deployment before rewards can be sold\\n  function setSwapRouter(address swapRouter) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xe62d2880420afb053498b01f1def17d4c8e2c6c9b48cc5a71d013150a5ca8db4\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISurplus.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISurplus {\\n  /// @dev This function will swap the surplus of a collateral for the stable asset link to the protocol.\\n  /// @param collateral The collateral address to process the surplus of.\\n  /// @param maxCollateralAmount The maximum amount of collateral to process. If 0, processes the full surplus.\\n  /// @return collateralSurplus The surplus of the collateral actually processed.\\n  /// @return stableSurplus The surplus amount in stable calculated from the collateral surplus.\\n  /// @return issuedAmount The amount of newly issued stablecoins from the collateral swapped\\n  function processSurplus(\\n    address collateral,\\n    uint256 maxCollateralAmount\\n  )\\n    external\\n    returns (uint256 collateralSurplus, uint256 stableSurplus, uint256 issuedAmount);\\n\\n  /// @notice Releases the income to the payees\\n  /// @return payees The addresses of the payees\\n  /// @return amounts The amounts released to the payees\\n  function release() external returns (address[] memory payees, uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x0129ea80a666d553ddd13c02f56a72cc96a6ac4e45578f0f523def2732ce450f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactInput`, but using a single EIP-3009 authorization for `tokenIn`.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeSwapExactInputNonce(...)`,\\n  /// which binds the full swap intent. `authData.nonce` carries the caller-chosen `userSalt`; the\\n  /// facet recomputes the derived nonce from the call arguments before forwarding it to the\\n  /// token, so any tampering with `to`/slippage/deadline invalidates the signature.\\n  /// @param authData ABI-encoded `AuthorizationParams` with `nonce = userSalt`\\n  function swapExactInputWithAuthorization(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata authData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactOutput`, but using a single EIP-3009 authorization for `tokenIn`.\\n  /// @dev The authorization must be signed for `amountInMax`; the excess is refunded to the\\n  /// authorizer. Derived-nonce scheme as in `swapExactInputWithAuthorization`, using\\n  /// `LibAuthorization.computeSwapExactOutputNonce(...)`.\\n  /// @param authData ABI-encoded `AuthorizationParams` with `nonce = userSalt`\\n  function swapExactOutputWithAuthorization(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata authData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0xbf7e08cff6dd51c222f86976d3526307098b80100c81978a55566043924cfc06\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"},\"project/libs/helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"}},\"version\":1}",
+  "storageLayout": {
+    "storage": [
+      {
+        "astId": 29857,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "_authority",
+        "offset": 0,
+        "slot": "0",
+        "type": "t_address"
+      },
+      {
+        "astId": 29859,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "_consumingSchedule",
+        "offset": 20,
+        "slot": "0",
+        "type": "t_bool"
+      },
+      {
+        "astId": 10262,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "yieldBearingData",
+        "offset": 0,
+        "slot": "1",
+        "type": "t_mapping(t_address,t_struct(YieldBearingParams)10202_storage)"
+      },
+      {
+        "astId": 10267,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "isTrusted",
+        "offset": 0,
+        "slot": "2",
+        "type": "t_mapping(t_address,t_bool)"
+      },
+      {
+        "astId": 30616,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "swapRouter",
+        "offset": 0,
+        "slot": "3",
+        "type": "t_address"
+      },
+      {
+        "astId": 30619,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "tokenTransferAddress",
+        "offset": 0,
+        "slot": "4",
+        "type": "t_address"
+      },
+      {
+        "astId": 11058,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "budget",
+        "offset": 0,
+        "slot": "5",
+        "type": "t_mapping(t_address,t_uint256)"
+      }
+    ],
+    "types": {
+      "t_address": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      },
+      "t_bool": {
+        "encoding": "inplace",
+        "label": "bool",
+        "numberOfBytes": "1"
+      },
+      "t_mapping(t_address,t_bool)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => bool)",
+        "numberOfBytes": "32",
+        "value": "t_bool"
+      },
+      "t_mapping(t_address,t_struct(YieldBearingParams)10202_storage)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => struct YieldBearingParams)",
+        "numberOfBytes": "32",
+        "value": "t_struct(YieldBearingParams)10202_storage"
+      },
+      "t_mapping(t_address,t_uint256)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => uint256)",
+        "numberOfBytes": "32",
+        "value": "t_uint256"
+      },
+      "t_struct(YieldBearingParams)10202_storage": {
+        "encoding": "inplace",
+        "label": "struct YieldBearingParams",
+        "members": [
+          {
+            "astId": 10191,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "asset",
+            "offset": 0,
+            "slot": "0",
+            "type": "t_address"
+          },
+          {
+            "astId": 10193,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "targetExposure",
+            "offset": 20,
+            "slot": "0",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10195,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "maxExposure",
+            "offset": 0,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10197,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "minExposure",
+            "offset": 8,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10199,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "overrideExposures",
+            "offset": 16,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10201,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "maxSlippage",
+            "offset": 24,
+            "slot": "1",
+            "type": "t_uint64"
+          }
+        ],
+        "numberOfBytes": "64"
+      },
+      "t_uint256": {
+        "encoding": "inplace",
+        "label": "uint256",
+        "numberOfBytes": "32"
+      },
+      "t_uint64": {
+        "encoding": "inplace",
+        "label": "uint64",
+        "numberOfBytes": "8"
+      }
+    }
+  },
+  "userdoc": {
+    "events": {
+      "SwapRouterUpdated(address)": {
+        "notice": "Event emitted when the swap router is updated"
+      },
+      "TokenTransferAddressUpdated(address)": {
+        "notice": "Event emitted when the token proxy is updated"
+      }
+    },
+    "kind": "user",
+    "methods": {
+      "addBudget(uint256,address)": {
+        "notice": "Add budget to be spent by the receiver during the flashloan"
+      },
+      "budget(address)": {
+        "notice": "Budget of tokenP available for each users"
+      },
+      "computeRebalanceAmount(address)": {
+        "notice": "Compute the amount needed to rebalance the Parallelizer"
+      },
+      "flashloan()": {
+        "notice": "Parallel stablecoin flashloan contract"
+      },
+      "harvest(address,uint256,bytes)": {
+        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
+      },
+      "isTrusted(address)": {
+        "notice": "trusted addresses that can update target exposure and do others non critical operations"
+      },
+      "parallelizer()": {
+        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
+      },
+      "recoverERC20(address,uint256,address)": {
+        "notice": "Recover ERC20 tokens"
+      },
+      "removeBudget(uint256,address)": {
+        "notice": "Remove budget from the owner and send it to the receiver"
+      },
+      "resetAllowance(address,address)": {
+        "notice": "Set an allowance this contract granted back to zero"
+      },
+      "setMaxSlippage(address,uint64)": {
+        "notice": "Set the max allowed slippage"
+      },
+      "setSwapRouter(address)": {
+        "notice": "Set the swap router"
+      },
+      "setTargetExposure(address,uint64)": {
+        "notice": "Set the target exposure of a yield bearing asset"
+      },
+      "setTokenTransferAddress(address)": {
+        "notice": "Set the token transfer address"
+      },
+      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": {
+        "notice": "Set the yieldBearingAsset data"
+      },
+      "swapRouter()": {
+        "notice": "address of the router/aggregator"
+      },
+      "toggleTrusted(address)": {
+        "notice": "Toggle the trusted status of an address"
+      },
+      "tokenP()": {
+        "notice": "TokenP handled by the `parallelizer` of interest"
+      },
+      "tokenTransferAddress()": {
+        "notice": "address to approve to transfer tokens to"
+      },
+      "updateLimitExposuresYieldAsset(address)": {
+        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
+      },
+      "yieldBearingData(address)": {
+        "notice": "Data associated to a yield bearing asset"
+      }
+    },
+    "version": 1
+  },
+  "argsData": "0x00000000000000000000000088de50b233052e4fb783d4f6db78cc34fea3e9fc00000000000000000000000088de50b233052e4fb783d4f6db78cc34fea3e9fc0000000000000000000000009ee1963f05553ef838604dd39403be21cef26aa400000000000000000000000041d58951cbd12d4ef49b0437897677bbf5547c800000000000000000000000001cbed02a8ac954390cba057290760f6d12489fa30000000000000000000000009e0dcf7a33bbde6689560c5c807dd2a3df991277",
+  "transaction": {
+    "hash": "0xba8f93f4a7dd2f776c410acd955dd0bf0b431dc3a0c7341a8dd67d025f4632d6",
+    "nonce": "0xe3",
+    "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
+  },
+  "receipt": {
+    "blockHash": "0xf1f1b2d5bfa2abd8afe2a6f07f89c3f33c0b5f953c5c3dddf5465c9db00d895e",
+    "blockNumber": "0x5c87339",
+    "transactionIndex": "0x7"
+  }
+}
\ No newline at end of file
diff --git a/deployments/avalanche/Getters.json b/deployments/avalanche/Getters.json
index 034a93b..e6a174a 100644
--- a/deployments/avalanche/Getters.json
+++ b/deployments/avalanche/Getters.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x457ee3ab077bd58d32e651d07bc3c4383039af55",
+  "address": "0x2fe66473d35a98131e1d08ff519378ad62dbbbef",
   "abi": [
     {
       "inputs": [],
@@ -549,6 +549,19 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "getSwapRouter",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [],
       "name": "getTotalIssued",
@@ -752,8 +765,8 @@
   ],
   "contractName": "Getters",
   "sourceName": "contracts/parallelizer/facets/Getters.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -804,7 +817,7 @@
       "getSlippageTolerance(address)": {
         "details": "Maximum slippage tolerance is 1e9 (100%)"
       },
-      "getSurplusBufferRatio()": {
+      "getSwapRouter()": {
         "details": "Expressed in base 1e9, and always >= 1e9"
       },
       "isConsumingScheduledOp()": {
@@ -823,9 +836,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "3346200",
-        "executionCost": "3721",
-        "totalCost": "3349921"
+        "codeDepositCost": "3358000",
+        "executionCost": "3737",
+        "totalCost": "3361737"
       },
       "external": {
         "accessManager()": "2418",
@@ -847,7 +860,8 @@
         "getShares(address)": "2561",
         "getSlippageTolerance(address)": "2564",
         "getStablecoinCap(address)": "infinite",
-        "getSurplusBufferRatio()": "2356",
+        "getSurplusBufferRatio()": "2334",
+        "getSwapRouter()": "2420",
         "getTotalIssued()": "infinite",
         "getTotalShares()": "2369",
         "isConsumingScheduledOp()": "infinite",
@@ -862,7 +876,7 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SurplusBufferRatioNotSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroSurplusAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"accessManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralBurnFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralDecimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isManaged\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isMintLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isBurnLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"onlyWhitelisted\",\"type\":\"uint8\"},{\"internalType\":\"uint216\",\"name\":\"normalizedStables\",\"type\":\"uint216\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinCap\",\"type\":\"uint256\"}],\"internalType\":\"struct Collateral\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralList\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralMintFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"collatRatio\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralSurplus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"collateralSurplus\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableSurplus\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralWhitelistData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getIssuedByCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stablecoinsFromCollateral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastReleasedAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getManagerData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracle\",\"outputs\":[{\"internalType\":\"enum OracleReadType\",\"name\":\"oracleType\",\"type\":\"uint8\"},{\"internalType\":\"enum OracleReadType\",\"name\":\"targetType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"oracleData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"targetData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hyperparameters\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracleValues\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"mint\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"burn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ratio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minRatio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"redemption\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPayees\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRedemptionFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xRedemptionCurve\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yRedemptionCurve\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"getShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getSlippageTolerance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getStablecoinCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSurplusBufferRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"enum ActionType\",\"name\":\"action\",\"type\":\"uint8\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrustedSeller\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"isValidSelector\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"isWhitelistedCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enum WhitelistType\",\"name\":\"whitelistType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForType\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"There may be duplicates in the info provided by the getters defined hereThis contract is an authorized fork of Angle's `Getters` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}]},\"kind\":\"dev\",\"methods\":{\"getCollateralRatio()\":{\"details\":\"This function may revert and overflow if the collateral ratio is too big due to a too small amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function become economically impossible\"},\"getCollateralSurplus(address)\":{\"params\":{\"collateral\":\"The collateral address to compute the surplus of.\"},\"returns\":{\"collateralSurplus\":\"The collateral surplus amount.\",\"stableSurplus\":\"The surplus in stable amount.\"}},\"getOracle(address)\":{\"returns\":{\"oracleData\":\"Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\",\"oracleType\":\"Type of oracle (Chainlink, external smart contract, ...)\",\"targetData\":\"Extra data needed to read the target price of the asset\",\"targetType\":\"Type passed to read the value of the target price\"}},\"getOracleValues(address)\":{\"details\":\"This function is not optimized for gas consumption as for instance the `burn` value for collateral is computed twice: once in `readBurn` and once in `getBurnOracle`\",\"returns\":{\"burn\":\"Oracle value that will be used for `collateral` for a burn transaction. This value is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\",\"minRatio\":\"Minimum ratio across all collateral assets between a collateral burn price and its target price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn transactions.\",\"mint\":\"Oracle value to be used for a mint transaction with `collateral`\",\"ratio\":\"Ratio, in base `10**18` between the oracle value of the `collateral` and its target price. This value is 10**18 if the oracle is greater than the collateral price\",\"redemption\":\"Oracle value that would be used to price `collateral` when computing the collateral ratio during a redemption\"}},\"getSlippageTolerance(address)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)\"},\"getSurplusBufferRatio()\":{\"details\":\"Expressed in base 1e9, and always >= 1e9\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"isWhitelistedForCollateral(address,address)\":{\"details\":\"This function is non view as it may consult external non view functions from whitelist providers\"},\"isWhitelistedForType(uint8,address)\":{\"details\":\"Note that ultimately whitelisting may depend as well on external providers\"}},\"title\":\"Getters\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"accessManager()\":{\"notice\":\"Returns the address of the `accessManager` contract\"},\"getCollateralBurnFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn for `collateral`\"},\"getCollateralDecimals(address)\":{\"notice\":\"Returns the decimals of a given `collateral`\"},\"getCollateralInfo(address)\":{\"notice\":\"Returns all the info in storage associated to a `collateral`\"},\"getCollateralList()\":{\"notice\":\"Returns the list of collateral assets supported by the system\"},\"getCollateralMintFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint with `collateral`\"},\"getCollateralRatio()\":{\"notice\":\"Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount of stablecoins issued\"},\"getCollateralSurplus(address)\":{\"notice\":\"Computes the surplus of a collateral.\"},\"getCollateralWhitelistData(address)\":{\"notice\":\"Gets the data needed to deal with whitelists for `collateral`\"},\"getIssuedByCollateral(address)\":{\"notice\":\"Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued through Parallelizer\"},\"getLastReleasedAt()\":{\"notice\":\"Returns the last time the income was released to the payees\"},\"getManagerData(address)\":{\"notice\":\"Returns if a collateral is \\\"managed\\\" and the associated manager configuration\"},\"getOracle(address)\":{\"notice\":\"Returns the data used to compute oracle values for `collateral`\"},\"getOracleValues(address)\":{\"notice\":\"Returns the oracle values associated to `collateral`\"},\"getPayees()\":{\"notice\":\"Returns the payees and their shares\"},\"getRedemptionFees()\":{\"notice\":\"Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral ratio when users come to redeem\"},\"getShares(address)\":{\"notice\":\"Returns the shares of a payee\"},\"getSlippageTolerance(address)\":{\"notice\":\"Returns the slippage tolerance for a `collateral` for the surplus\"},\"getStablecoinCap(address)\":{\"notice\":\"Returns the stablecoin cap for `collateral`\"},\"getSurplusBufferRatio()\":{\"notice\":\"Returns the minimum collateral ratio that must hold after surplus processing\"},\"getTotalIssued()\":{\"notice\":\"Returns the total amount of stablecoins issued through Parallelizer\"},\"getTotalShares()\":{\"notice\":\"Returns the total shares of the payees\"},\"isPaused(address,uint8)\":{\"notice\":\"Returns if the associated functionality is paused or not\"},\"isTrusted(address)\":{\"notice\":\"Returns if `sender` is trusted to update normalizers\"},\"isTrustedSeller(address)\":{\"notice\":\"Returns if `sender` is trusted to update sell rewards\"},\"isValidSelector(bytes4)\":{\"notice\":\"Checks whether a given `selector` is actually a valid selector corresponding to a function in one of the facets of the proxy\"},\"isWhitelistedCollateral(address)\":{\"notice\":\"Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForCollateral(address,address)\":{\"notice\":\"Checks whether `sender` can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForType(uint8,address)\":{\"notice\":\"Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\"},\"tokenP()\":{\"notice\":\"Stablecoin minted by parallelizer\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Getters.sol\":\"Getters\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x04f12ddeb53bb3bba9aaf9a93c62a84076cca496642d4d87556b15120b60e07b\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Getters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IGetters } from \\\"contracts/interfaces/IGetters.sol\\\";\\n\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibSurplus } from \\\"../libraries/LibSurplus.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Getters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev There may be duplicates in the info provided by the getters defined here\\n/// @dev This contract is an authorized fork of Angle's `Getters` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\\ncontract Getters is IGetters {\\n  /// @inheritdoc IGetters\\n  function isValidSelector(bytes4 selector) external view returns (bool) {\\n    return s.diamondStorage().selectorInfo[selector].facetAddress != address(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function tokenP() external view returns (ITokenP) {\\n    return s.transmuterStorage().tokenP;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralList() external view returns (address[] memory) {\\n    return s.transmuterStorage().collateralList;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory) {\\n    return s.transmuterStorage().collaterals[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralDecimals(address collateral) external view returns (uint8) {\\n    return s.transmuterStorage().collaterals[collateral].decimals;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralMintFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeMint, int64[] memory yFeeMint)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeMint, collatInfo.yFeeMint);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralBurnFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeBurn, int64[] memory yFeeBurn)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeBurn, collatInfo.yFeeBurn);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getRedemptionFees()\\n    external\\n    view\\n    returns (uint64[] memory xRedemptionCurve, int64[] memory yRedemptionCurve)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (ts.xRedemptionCurve, ts.yRedemptionCurve);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function may revert and overflow if the collateral ratio is too big due to a too small\\n  /// amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non\\n  /// negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function\\n  /// become economically impossible\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n\\n    (collatRatio, stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    return (\\n      (uint256(ts.collaterals[collateral].normalizedStables) * _normalizer) / BASE_27,\\n      (uint256(ts.normalizedStables) * _normalizer) / BASE_27\\n    );\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalIssued() external view returns (uint256) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (uint256(ts.normalizedStables) * uint256(ts.normalizer)) / BASE_27;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getManagerData(address collateral) external view returns (bool, IERC20[] memory, bytes memory) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      return (true, collatInfo.managerData.subCollaterals, collatInfo.managerData.config);\\n    }\\n    return (false, new IERC20[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is not optimized for gas consumption as for instance the `burn` value for collateral\\n  /// is computed twice: once in `readBurn` and once in `getBurnOracle`\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption)\\n  {\\n    bytes memory oracleConfig = s.transmuterStorage().collaterals[collateral].oracleConfig;\\n    (burn, ratio) = LibOracle.readBurn(oracleConfig);\\n    (minRatio,) = LibOracle.getBurnOracle(collateral, oracleConfig);\\n    return (LibOracle.readMint(oracleConfig), burn, ratio, minRatio, LibOracle.readRedemption(oracleConfig));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    )\\n  {\\n    return LibOracle.getOracle(collateral);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isPaused(address collateral, ActionType action) external view returns (bool) {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      if (action == ActionType.Mint) {\\n        return collatInfo.isMintLive == 0;\\n      } else {\\n        return collatInfo.isBurnLive == 0;\\n      }\\n    } else {\\n      return s.transmuterStorage().isRedemptionLive == 0;\\n    }\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrusted(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrustedSeller(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isSellerTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool) {\\n    return s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is non view as it may consult external non view functions from whitelist providers\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.onlyWhitelisted == 0 || LibWhitelist.checkWhitelist(collatInfo.whitelistData, sender));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedCollateral(address collateral) external view returns (bool) {\\n    return s.transmuterStorage().collaterals[collateral].onlyWhitelisted == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory) {\\n    return s.transmuterStorage().collaterals[collateral].whitelistData;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getStablecoinCap(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().collaterals[collateral].stablecoinCap;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function accessManager() external view returns (address) {\\n    return address(s.diamondStorage().accessManager);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isConsumingScheduledOp() external view returns (bytes4) {\\n    return s.transmuterStorage().consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getPayees() external view returns (address[] memory, uint256[] memory) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory payees = new address[](ts.payees.length);\\n    uint256[] memory shares = new uint256[](ts.payees.length);\\n    for (uint256 i = 0; i < ts.payees.length; i++) {\\n      payees[i] = ts.payees[i];\\n      shares[i] = ts.shares[ts.payees[i]];\\n    }\\n    return (payees, shares);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalShares() external view returns (uint256) {\\n    return s.transmuterStorage().totalShares;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getShares(address payee) external view returns (uint256) {\\n    return s.transmuterStorage().shares[payee];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSlippageTolerance(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().slippageTolerance[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSurplusBufferRatio() external view returns (uint64) {\\n    return s.transmuterStorage().surplusBufferRatio;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getLastReleasedAt() external view returns (uint256) {\\n    return s.transmuterStorage().lastReleasedAt;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    return LibSurplus._computeCollateralSurplus(collateral);\\n  }\\n}\\n\",\"keccak256\":\"0xd53f1dc85e3e3b30205017bf00b54c9b511963034d382ecc647e65ad854b314e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SurplusBufferRatioNotSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroSurplusAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"accessManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralBurnFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralDecimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isManaged\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isMintLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isBurnLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"onlyWhitelisted\",\"type\":\"uint8\"},{\"internalType\":\"uint216\",\"name\":\"normalizedStables\",\"type\":\"uint216\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinCap\",\"type\":\"uint256\"}],\"internalType\":\"struct Collateral\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralList\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralMintFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"collatRatio\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralSurplus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"collateralSurplus\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableSurplus\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralWhitelistData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getIssuedByCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stablecoinsFromCollateral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastReleasedAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getManagerData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracle\",\"outputs\":[{\"internalType\":\"enum OracleReadType\",\"name\":\"oracleType\",\"type\":\"uint8\"},{\"internalType\":\"enum OracleReadType\",\"name\":\"targetType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"oracleData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"targetData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hyperparameters\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracleValues\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"mint\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"burn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ratio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minRatio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"redemption\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPayees\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRedemptionFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xRedemptionCurve\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yRedemptionCurve\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"getShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getSlippageTolerance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getStablecoinCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSurplusBufferRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSwapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"enum ActionType\",\"name\":\"action\",\"type\":\"uint8\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrustedSeller\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"isValidSelector\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"isWhitelistedCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enum WhitelistType\",\"name\":\"whitelistType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForType\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"There may be duplicates in the info provided by the getters defined hereThis contract is an authorized fork of Angle's `Getters` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}]},\"kind\":\"dev\",\"methods\":{\"getCollateralRatio()\":{\"details\":\"This function may revert and overflow if the collateral ratio is too big due to a too small amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function become economically impossible\"},\"getCollateralSurplus(address)\":{\"params\":{\"collateral\":\"The collateral address to compute the surplus of.\"},\"returns\":{\"collateralSurplus\":\"The collateral surplus amount.\",\"stableSurplus\":\"The surplus in stable amount.\"}},\"getOracle(address)\":{\"returns\":{\"oracleData\":\"Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\",\"oracleType\":\"Type of oracle (Chainlink, external smart contract, ...)\",\"targetData\":\"Extra data needed to read the target price of the asset\",\"targetType\":\"Type passed to read the value of the target price\"}},\"getOracleValues(address)\":{\"details\":\"This function is not optimized for gas consumption as for instance the `burn` value for collateral is computed twice: once in `readBurn` and once in `getBurnOracle`\",\"returns\":{\"burn\":\"Oracle value that will be used for `collateral` for a burn transaction. This value is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\",\"minRatio\":\"Minimum ratio across all collateral assets between a collateral burn price and its target price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn transactions.\",\"mint\":\"Oracle value to be used for a mint transaction with `collateral`\",\"ratio\":\"Ratio, in base `10**18` between the oracle value of the `collateral` and its target price. This value is 10**18 if the oracle is greater than the collateral price\",\"redemption\":\"Oracle value that would be used to price `collateral` when computing the collateral ratio during a redemption\"}},\"getSlippageTolerance(address)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)\"},\"getSwapRouter()\":{\"details\":\"Expressed in base 1e9, and always >= 1e9\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"isWhitelistedForCollateral(address,address)\":{\"details\":\"This function is non view as it may consult external non view functions from whitelist providers\"},\"isWhitelistedForType(uint8,address)\":{\"details\":\"Note that ultimately whitelisting may depend as well on external providers\"}},\"title\":\"Getters\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"accessManager()\":{\"notice\":\"Returns the address of the `accessManager` contract\"},\"getCollateralBurnFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn for `collateral`\"},\"getCollateralDecimals(address)\":{\"notice\":\"Returns the decimals of a given `collateral`\"},\"getCollateralInfo(address)\":{\"notice\":\"Returns all the info in storage associated to a `collateral`\"},\"getCollateralList()\":{\"notice\":\"Returns the list of collateral assets supported by the system\"},\"getCollateralMintFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint with `collateral`\"},\"getCollateralRatio()\":{\"notice\":\"Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount of stablecoins issued\"},\"getCollateralSurplus(address)\":{\"notice\":\"Computes the surplus of a collateral.\"},\"getCollateralWhitelistData(address)\":{\"notice\":\"Gets the data needed to deal with whitelists for `collateral`\"},\"getIssuedByCollateral(address)\":{\"notice\":\"Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued through Parallelizer\"},\"getLastReleasedAt()\":{\"notice\":\"Returns the last time the income was released to the payees\"},\"getManagerData(address)\":{\"notice\":\"Returns if a collateral is \\\"managed\\\" and the associated manager configuration\"},\"getOracle(address)\":{\"notice\":\"Returns the data used to compute oracle values for `collateral`\"},\"getOracleValues(address)\":{\"notice\":\"Returns the oracle values associated to `collateral`\"},\"getPayees()\":{\"notice\":\"Returns the payees and their shares\"},\"getRedemptionFees()\":{\"notice\":\"Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral ratio when users come to redeem\"},\"getShares(address)\":{\"notice\":\"Returns the shares of a payee\"},\"getSlippageTolerance(address)\":{\"notice\":\"Returns the slippage tolerance for a `collateral` for the surplus\"},\"getStablecoinCap(address)\":{\"notice\":\"Returns the stablecoin cap for `collateral`\"},\"getSwapRouter()\":{\"notice\":\"Returns the minimum collateral ratio that must hold after surplus processingReturns the aggregator or DEX the `RewardHandler` forwards its swap payload to\"},\"getTotalIssued()\":{\"notice\":\"Returns the total amount of stablecoins issued through Parallelizer\"},\"getTotalShares()\":{\"notice\":\"Returns the total shares of the payees\"},\"isPaused(address,uint8)\":{\"notice\":\"Returns if the associated functionality is paused or not\"},\"isTrusted(address)\":{\"notice\":\"Returns if `sender` is trusted to update normalizers\"},\"isTrustedSeller(address)\":{\"notice\":\"Returns if `sender` is trusted to update sell rewards\"},\"isValidSelector(bytes4)\":{\"notice\":\"Checks whether a given `selector` is actually a valid selector corresponding to a function in one of the facets of the proxy\"},\"isWhitelistedCollateral(address)\":{\"notice\":\"Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForCollateral(address,address)\":{\"notice\":\"Checks whether `sender` can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForType(uint8,address)\":{\"notice\":\"Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\"},\"tokenP()\":{\"notice\":\"Stablecoin minted by parallelizer\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Getters.sol\":\"Getters\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  function getSwapRouter() external view returns (address);\\n\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x27a333b02ba124b5964a63bddeb301328197bddbe98538903cd41a8b40900d12\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Getters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IGetters } from \\\"contracts/interfaces/IGetters.sol\\\";\\n\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibSurplus } from \\\"../libraries/LibSurplus.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Getters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev There may be duplicates in the info provided by the getters defined here\\n/// @dev This contract is an authorized fork of Angle's `Getters` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\\ncontract Getters is IGetters {\\n  /// @inheritdoc IGetters\\n  function isValidSelector(bytes4 selector) external view returns (bool) {\\n    return s.diamondStorage().selectorInfo[selector].facetAddress != address(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function tokenP() external view returns (ITokenP) {\\n    return s.transmuterStorage().tokenP;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralList() external view returns (address[] memory) {\\n    return s.transmuterStorage().collateralList;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory) {\\n    return s.transmuterStorage().collaterals[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralDecimals(address collateral) external view returns (uint8) {\\n    return s.transmuterStorage().collaterals[collateral].decimals;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralMintFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeMint, int64[] memory yFeeMint)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeMint, collatInfo.yFeeMint);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralBurnFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeBurn, int64[] memory yFeeBurn)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeBurn, collatInfo.yFeeBurn);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getRedemptionFees()\\n    external\\n    view\\n    returns (uint64[] memory xRedemptionCurve, int64[] memory yRedemptionCurve)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (ts.xRedemptionCurve, ts.yRedemptionCurve);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function may revert and overflow if the collateral ratio is too big due to a too small\\n  /// amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non\\n  /// negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function\\n  /// become economically impossible\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n\\n    (collatRatio, stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    return (\\n      (uint256(ts.collaterals[collateral].normalizedStables) * _normalizer) / BASE_27,\\n      (uint256(ts.normalizedStables) * _normalizer) / BASE_27\\n    );\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalIssued() external view returns (uint256) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (uint256(ts.normalizedStables) * uint256(ts.normalizer)) / BASE_27;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getManagerData(address collateral) external view returns (bool, IERC20[] memory, bytes memory) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      return (true, collatInfo.managerData.subCollaterals, collatInfo.managerData.config);\\n    }\\n    return (false, new IERC20[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is not optimized for gas consumption as for instance the `burn` value for collateral\\n  /// is computed twice: once in `readBurn` and once in `getBurnOracle`\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption)\\n  {\\n    bytes memory oracleConfig = s.transmuterStorage().collaterals[collateral].oracleConfig;\\n    (burn, ratio) = LibOracle.readBurn(oracleConfig);\\n    (minRatio,) = LibOracle.getBurnOracle(collateral, oracleConfig);\\n    return (LibOracle.readMint(oracleConfig), burn, ratio, minRatio, LibOracle.readRedemption(oracleConfig));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    )\\n  {\\n    return LibOracle.getOracle(collateral);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isPaused(address collateral, ActionType action) external view returns (bool) {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      if (action == ActionType.Mint) {\\n        return collatInfo.isMintLive == 0;\\n      } else {\\n        return collatInfo.isBurnLive == 0;\\n      }\\n    } else {\\n      return s.transmuterStorage().isRedemptionLive == 0;\\n    }\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrusted(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrustedSeller(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isSellerTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool) {\\n    return s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is non view as it may consult external non view functions from whitelist providers\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.onlyWhitelisted == 0 || LibWhitelist.checkWhitelist(collatInfo.whitelistData, sender));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedCollateral(address collateral) external view returns (bool) {\\n    return s.transmuterStorage().collaterals[collateral].onlyWhitelisted == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory) {\\n    return s.transmuterStorage().collaterals[collateral].whitelistData;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getStablecoinCap(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().collaterals[collateral].stablecoinCap;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function accessManager() external view returns (address) {\\n    return address(s.diamondStorage().accessManager);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isConsumingScheduledOp() external view returns (bytes4) {\\n    return s.transmuterStorage().consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getPayees() external view returns (address[] memory, uint256[] memory) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory payees = new address[](ts.payees.length);\\n    uint256[] memory shares = new uint256[](ts.payees.length);\\n    for (uint256 i = 0; i < ts.payees.length; i++) {\\n      payees[i] = ts.payees[i];\\n      shares[i] = ts.shares[ts.payees[i]];\\n    }\\n    return (payees, shares);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalShares() external view returns (uint256) {\\n    return s.transmuterStorage().totalShares;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getShares(address payee) external view returns (uint256) {\\n    return s.transmuterStorage().shares[payee];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSlippageTolerance(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().slippageTolerance[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSwapRouter() external view returns (address) {\\n    return s.transmuterStorage().swapRouter;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSurplusBufferRatio() external view returns (uint64) {\\n    return s.transmuterStorage().surplusBufferRatio;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getLastReleasedAt() external view returns (uint256) {\\n    return s.transmuterStorage().lastReleasedAt;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    return LibSurplus._computeCollateralSurplus(collateral);\\n  }\\n}\\n\",\"keccak256\":\"0x7698420203383c245b91740b40652708e240877ec9d006d211556c7ffe0406e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -927,8 +941,8 @@
       "getStablecoinCap(address)": {
         "notice": "Returns the stablecoin cap for `collateral`"
       },
-      "getSurplusBufferRatio()": {
-        "notice": "Returns the minimum collateral ratio that must hold after surplus processing"
+      "getSwapRouter()": {
+        "notice": "Returns the minimum collateral ratio that must hold after surplus processingReturns the aggregator or DEX the `RewardHandler` forwards its swap payload to"
       },
       "getTotalIssued()": {
         "notice": "Returns the total amount of stablecoins issued through Parallelizer"
@@ -965,13 +979,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0x4fffa60ff29527a9237985a702100f6ba2fb121dcce486746fe2495ef0a4814f",
-    "nonce": "0xc5",
+    "hash": "0x2c0b33ca04de8cf311e3fb4dca8a58f72158cfd15f216436745da82969972716",
+    "nonce": "0xe0",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
-    "blockHash": "0xafe3d156c3be43422eb652c0e21119a16c42a6da4eb24d266acaba5e7ac50d06",
-    "blockNumber": "0x56e29e0",
-    "transactionIndex": "0x3"
+    "blockHash": "0xa617d003c0e933609e06147a3f4a03c957955b41e8a4957299506aa0c95b366b",
+    "blockNumber": "0x5c76695",
+    "transactionIndex": "0x1"
   }
 }
\ No newline at end of file
diff --git a/deployments/avalanche/Redeemer.json b/deployments/avalanche/Redeemer.json
index 0d2ae68..3c56e15 100644
--- a/deployments/avalanche/Redeemer.json
+++ b/deployments/avalanche/Redeemer.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x8f1d81c0af5675e6ade9db1dbf03750310b0c2e3",
+  "address": "0x58426574855da7a8c47e1d134d51fd17dca5129b",
   "abi": [
     {
       "inputs": [],
@@ -78,6 +78,11 @@
       "name": "TooSmallAmountOut",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "UnexpectedRedemptionTokens",
+      "type": "error"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -179,6 +184,11 @@
           "internalType": "uint256[]",
           "name": "minAmountOuts",
           "type": "uint256[]"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
         }
       ],
       "name": "redeem",
@@ -224,6 +234,11 @@
           "name": "forfeitTokens",
           "type": "address[]"
         },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
+        },
         {
           "internalType": "bytes",
           "name": "authData",
@@ -272,6 +287,11 @@
           "internalType": "address[]",
           "name": "forfeitTokens",
           "type": "address[]"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
         }
       ],
       "name": "redeemWithForfeit",
@@ -317,8 +337,8 @@
   ],
   "contractName": "Redeemer",
   "sourceName": "contracts/parallelizer/facets/Redeemer.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -347,10 +367,11 @@
           "tokens": "List of tokens that would be given"
         }
       },
-      "redeem(uint256,address,uint256,uint256[])": {
+      "redeem(uint256,address,uint256,uint256[],bytes32)": {
         "details": "The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function",
         "params": {
           "deadline": "Timestamp before which the redemption should have occured",
+          "expectedTokensHash": "`keccak256(abi.encodePacked(tokens))` over the output list the caller was quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since `minAmountOuts` is positional and a collateral rotation can change which token each entry protects",
           "minAmountOuts": "Minimum amount of each token given back in the redemption to obtain",
           "receiver": "Address which should be receiving the output tokens"
         },
@@ -359,10 +380,10 @@
           "tokens": "List of tokens returned"
         }
       },
-      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": {
-        "details": "The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`."
+      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": {
+        "details": "The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.`expectedTokensHash` matters most here: a signature stays executable for its whole validity window, so without it a relayer could hold one until a collateral rotation reshuffles the output list"
       },
-      "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": {
+      "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": {
         "details": "Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount"
       },
       "updateNormalizer(uint256,bool)": {
@@ -375,28 +396,28 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "2988000",
-        "executionCost": "3276",
-        "totalCost": "2991276"
+        "codeDepositCost": "3024800",
+        "executionCost": "3323",
+        "totalCost": "3028123"
       },
       "external": {
         "quoteRedemptionCurve(uint256)": "infinite",
-        "redeem(uint256,address,uint256,uint256[])": "infinite",
-        "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": "infinite",
-        "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": "infinite",
+        "redeem(uint256,address,uint256,uint256[],bytes32)": "infinite",
+        "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": "infinite",
+        "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": "infinite",
         "updateNormalizer(uint256,bool)": "infinite"
       },
       "internal": {
-        "_consumeAuthAndBurn(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_consumeAuthAndBurn(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_distributeRedemption(struct Redeemer.RedemptionExecution memory)": "infinite",
-        "_executeAuthorization(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_executeAuthorization(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_quoteRedemptionCurve(uint256)": "infinite",
-        "_redeem(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_redeem(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_updateNormalizer(uint256,bool)": "infinite"
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"CannotBurnAllStableIssued\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotWhitelisted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNormalizerValue\",\"type\":\"uint256\"}],\"name\":\"NormalizerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Redeemed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"quoteRedemptionCurve\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"}],\"name\":\"redeem\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"authData\",\"type\":\"bytes\"}],\"name\":\"redeemWithAuthorization\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"}],\"name\":\"redeemWithForfeit\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"updateNormalizer\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `Redeemer` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"returns\":{\"amounts\":\"Amount that would be obtained for each token in the `tokens` array\",\"tokens\":\"List of tokens that would be given\"}},\"redeem(uint256,address,uint256,uint256[])\":{\"details\":\"The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function\",\"params\":{\"deadline\":\"Timestamp before which the redemption should have occured\",\"minAmountOuts\":\"Minimum amount of each token given back in the redemption to obtain\",\"receiver\":\"Address which should be receiving the output tokens\"},\"returns\":{\"amounts\":\"Amount given for each token in the `tokens` array\",\"tokens\":\"List of tokens returned\"}},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)\":{\"details\":\"The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[])\":{\"details\":\"Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount\"},\"updateNormalizer(uint256,bool)\":{\"details\":\"This function may be called by trusted addresses: these could be for instance savings contract minting stablecoins when they notice a profit\"}},\"title\":\"Redeemer\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"notice\":\"Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\"},\"redeem(uint256,address,uint256,uint256[])\":{\"notice\":\"Redeems `amount` of stablecoins from the system\"},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)\":{\"notice\":\"Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[])\":{\"notice\":\"Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`.\"},\"updateNormalizer(uint256,bool)\":{\"notice\":\"Updates the normalizer variable by `amount`\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Redeemer.sol\":\"Redeemer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the\\n  /// signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x2ea4d5ebd3dd0e83071ebedb2c269f501f37033ddce9a1ee9ec40cfde0adfc7a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IEIP3009.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IEIP3009\\n/// @notice Interface for EIP-3009: Transfer With Authorization\\ninterface IEIP3009 {\\n  /// @notice Execute a transfer with a signed authorization (EOA signature)\\n  /// @dev SECURITY: anyone may submit this call (no `msg.sender` restriction). Integrators that\\n  /// pair the transfer with downstream logic (e.g. swap, deposit, redeem) MUST use\\n  /// `receiveWithAuthorization` instead: a mempool watcher can otherwise frontrun the original\\n  /// transaction with a raw `transferWithAuthorization`, burning the nonce so the original\\n  /// reverts while the funds still move - causing the post-transfer logic to be skipped.\\n  /// Use this primitive only for direct payouts to a passive recipient (`msg.sender != to`).\\n  /// @param from The address of the sender\\n  /// @param to The address of the recipient\\n  /// @param value The amount of tokens to transfer\\n  /// @param validAfter The timestamp after which the authorization is valid\\n  /// @param validBefore The timestamp before which the authorization is valid\\n  /// @param nonce The nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Execute a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev SECURITY: see the EOA overload - this primitive is frontrun-prone and must not be used\\n  /// when the transfer is bound to follow-on logic. Use `receiveWithAuthorization` in that case.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EOA signature)\\n  /// @dev The caller must be the payee (`to` address). This has an additional check to ensure\\n  /// that the payee's address matches the caller of this function to prevent front-running attacks.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev The caller must be the payee (`to` address)\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Attempt to cancel an authorization\\n  /// @dev Works only if the authorization is not yet used.\\n  /// EOA wallet signatures should be packed in the order of r, s, v.\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external;\\n\\n  /// @notice Cancel an authorization (EIP-1271 compatible)\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external;\\n\\n  /// @notice Returns the state of an authorization\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @return true if the nonce is used\\n  function authorizationState(address authorizer, bytes32 nonce) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe34cfb584a925054c2e3569c4401c619cd2b928a7b9da04537e71a9089edf55a\",\"license\":\"MIT\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Redeemer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IRedeemer } from \\\"contracts/interfaces/IRedeemer.sol\\\";\\nimport { IEIP3009 } from \\\"contracts/interfaces/external/IEIP3009.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\nimport { LibAuthorization } from \\\"../libraries/LibAuthorization.sol\\\";\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Redeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `Redeemer` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\\ncontract Redeemer is IRedeemer, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  event Redeemed(\\n    uint256 amount,\\n    address[] tokens,\\n    uint256[] amounts,\\n    address[] forfeitTokens,\\n    address indexed from,\\n    address indexed to\\n  );\\n  event NormalizerUpdated(uint256 newNormalizerValue);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev The `minAmountOuts` list must reflect the amount of `tokens` returned\\n  /// @dev In normal conditions, the amount of tokens outputted by this function should be the amount\\n  /// of collateral assets supported by the system, following their order in the `collateralList`.\\n  /// @dev If one collateral has its liquidity managed through strategies, then it's possible that this asset\\n  /// has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption\\n  /// process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral\\n  /// assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering\\n  /// of the token list will be as follows:\\n  /// `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`\\n  /// @dev The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained\\n  /// by calling the `quoteRedemptionCurve` function\\n  /// @dev Tokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the\\n  /// whitelist, otherwise this function reverts\\n  /// @dev No approval is needed before calling this function\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token\\n  /// even if it has enough immediately available to send the amount\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, authData);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev This function may be called by trusted addresses: these could be for instance savings contract\\n  /// minting stablecoins when they notice a profit\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256) {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && s.transmuterStorage().isTrusted[msg.sender] == 0) {\\n      revert NotTrusted();\\n    }\\n    return _updateNormalizer(amount, increase);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    (tokens, amounts,) = _quoteRedemptionCurve(amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Working set passed by reference between `_redeem` and its loop helper, so the call\\n  /// site stays under the EVM stack-depth limit when compiling without via-IR.\\n  struct RedemptionExecution {\\n    uint256 amount;\\n    address from;\\n    address to;\\n    address[] tokens;\\n    uint256[] amounts;\\n    uint256[] subCollateralsTracker;\\n    uint256[] minAmountOuts;\\n    address[] forfeitTokens;\\n  }\\n\\n  /// @notice Internal function of the `redeem` function in the `Redeemer` contract\\n  function _redeem(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    nonReentrant\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    if (s.transmuterStorage().isRedemptionLive == 0) revert Paused();\\n    if (block.timestamp > deadline) revert TooLate();\\n\\n    RedemptionExecution memory redemption;\\n    redemption.amount = amount;\\n    redemption.to = to;\\n    redemption.minAmountOuts = minAmountOuts;\\n    redemption.forfeitTokens = forfeitTokens;\\n\\n    (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);\\n    if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();\\n    _updateNormalizer(amount, false);\\n\\n    redemption.from = _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, authData);\\n\\n    _distributeRedemption(redemption);\\n    emit Redeemed(\\n      redemption.amount,\\n      redemption.tokens,\\n      redemption.amounts,\\n      redemption.forfeitTokens,\\n      redemption.from,\\n      redemption.to\\n    );\\n    return (redemption.tokens, redemption.amounts);\\n  }\\n\\n  /// @notice Releases each non-forfeited collateral output to `redemption.to`. Extracted from `_redeem`\\n  /// so the parent function stays within the EVM stack-depth limit.\\n  function _distributeRedemption(RedemptionExecution memory redemption) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 indexCollateral;\\n    uint256 amountsLength = redemption.amounts.length;\\n    for (uint256 i; i < amountsLength; ++i) {\\n      if (redemption.amounts[i] < redemption.minAmountOuts[i]) revert TooSmallAmountOut();\\n      // If a token is in the `forfeitTokens` list, then it is not sent as part of the redemption process\\n      if (redemption.amounts[i] > 0 && LibHelpers.checkList(redemption.tokens[i], redemption.forfeitTokens) < 0) {\\n        Collateral storage collatInfo = ts.collaterals[collateralListMem[indexCollateral]];\\n        if (collatInfo.onlyWhitelisted > 0 && !LibWhitelist.checkWhitelist(collatInfo.whitelistData, redemption.to)) {\\n          revert NotWhitelisted();\\n        }\\n        if (collatInfo.isManaged > 0) {\\n          LibManager.release(\\n            redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config\\n          );\\n        } else {\\n          IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);\\n        }\\n      }\\n      if (redemption.subCollateralsTracker[indexCollateral] - 1 <= i) ++indexCollateral;\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer (auth flow) or burns directly from\\n  /// `msg.sender`, and returns the address to attribute the `Redeemed` event to.\\n  function _consumeAuthAndBurn(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    ITokenP tokenP = s.transmuterStorage().tokenP;\\n    if (authData.length > 0) {\\n      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, authData);\\n      tokenP.burnSelf(amount, address(this));\\n    } else {\\n      from = msg.sender;\\n      tokenP.burnSelf(amount, msg.sender);\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer via EIP-3009 `receiveWithAuthorization`,\\n  /// using a derived nonce that binds the full redemption intent.\\n  /// @return from The authorizer address (`params.from`), to attribute the redeem event to\\n  function _executeAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));\\n    if (params.value != amount) revert InvalidSwap();\\n    bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(\\n      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, params.nonce\\n    );\\n    IEIP3009(address(s.transmuterStorage().tokenP)).receiveWithAuthorization(\\n      params.from,\\n      address(this),\\n      params.value,\\n      params.validAfter,\\n      params.validBefore,\\n      derivedNonce,\\n      params.signature\\n    );\\n    return params.from;\\n  }\\n\\n  /// @dev This function reverts if `stablecoinsIssued==0`, which is expected behavior as there is nothing to redeem\\n  /// anyway in this case, or if the `amountBurnt` is greater than `stablecoinsIssued`\\n  /// @dev Invariant: `penaltyFactor` is evaluated once at the entry-time `collatRatio` and applied uniformly to the\\n  /// full `amountBurnt`. The curve is not path-integrated, so a single redemption that traverses into a lower-penalty\\n  /// segment still pays the entry-time rate on every unit burned. Splitting the same redemption into smaller calls\\n  /// can yield a strictly better blended rate when the path crosses an ascending segment of the curve. This is a\\n  /// deliberate design choice consistent with penalizing early redemptions during under-collateralization; the gap\\n  /// between single-call and path-integrated pricing scales with the ascending-segment slope and should be\\n  /// considered when calibrating `xRedemptionCurve`/`yRedemptionCurve`.\\n  function _quoteRedemptionCurve(uint256 amountBurnt)\\n    internal\\n    view\\n    returns (address[] memory tokens, uint256[] memory balances, uint256[] memory subCollateralsTracker)\\n  {\\n    uint64 collatRatio;\\n    uint256 stablecoinsIssued;\\n    (collatRatio, stablecoinsIssued, tokens, balances, subCollateralsTracker) = LibGetters.getCollateralRatio();\\n    if (amountBurnt >= stablecoinsIssued) revert CannotBurnAllStableIssued();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    int64[] memory yRedemptionCurveMem = ts.yRedemptionCurve;\\n    uint64 penaltyFactor;\\n    // If the protocol is under-collateralized, a penalty factor is applied to the returned amount of each asset\\n    if (collatRatio < BASE_9) {\\n      uint64[] memory xRedemptionCurveMem = ts.xRedemptionCurve;\\n      penaltyFactor = uint64(LibHelpers.piecewiseLinear(collatRatio, xRedemptionCurveMem, yRedemptionCurveMem));\\n    }\\n\\n    for (uint256 i; i < balances.length; ++i) {\\n      // The amount given for each token in reserves does not depend on the price of the tokens in reserve:\\n      // it is a proportion of the balance for each token computed as the ratio between the stablecoins\\n      // burnt relative to the amount of stablecoins issued.\\n      // If the protocol is over-collateralized, the amount of each token given is inversely proportional\\n      // to the collateral ratio.\\n      balances[i] = collatRatio >= BASE_9\\n        ? (amountBurnt * balances[i] * (uint64(yRedemptionCurveMem[yRedemptionCurveMem.length - 1])))\\n          / (stablecoinsIssued * collatRatio)\\n        : (amountBurnt * balances[i] * penaltyFactor) / (stablecoinsIssued * BASE_9);\\n    }\\n  }\\n\\n  /// @notice Updates the `normalizer` variable used to track stablecoins issued from each asset and globally\\n  function _updateNormalizer(uint256 amount, bool increase) internal returns (uint256 newNormalizerValue) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    uint256 _normalizedStables = ts.normalizedStables;\\n    // In case of an increase, the update formula used is the simplified version of the formula below:\\n    /*\\n            _normalizer * (BASE_27 + BASE_27 * amount / stablecoinsIssued) / BASE_27\\n        = _normalizer + (_normalizer * BASE_27 * amount * (BASE_27 / (_normalizedStables * normalizer))) / BASE_27\\n             = _normalizer + BASE_27 * amount / _normalizedStables\\n        */\\n    if (increase) {\\n      newNormalizerValue = _normalizer + (amount * BASE_27) / _normalizedStables;\\n    } else {\\n      newNormalizerValue = _normalizer - (amount * BASE_27) / _normalizedStables;\\n    }\\n    // If the `normalizer` gets too small or too big, it must be renormalized to later avoid the propagation of\\n    // rounding errors, as well as overflows. In this case, the function has to iterate through all the\\n    // supported collateral assets\\n    if (newNormalizerValue <= BASE_18 || newNormalizerValue >= BASE_36) {\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 collateralListLength = collateralListMem.length;\\n      // For each asset, we store the actual amount of stablecoins issued based on the `newNormalizerValue`\\n      // (and not a normalized value)\\n      // We ensure to preserve the invariant `sum(collateralNewNormalizedStables) = normalizedStables`\\n      uint128 newNormalizedStables;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        uint128 newCollateralNormalizedStable = ((uint256(ts.collaterals[collateralListMem[i]].normalizedStables)\\n              * newNormalizerValue) / BASE_27)\\n        .toUint128();\\n        newNormalizedStables += newCollateralNormalizedStable;\\n        ts.collaterals[collateralListMem[i]].normalizedStables = uint216(newCollateralNormalizedStable);\\n      }\\n      ts.normalizedStables = newNormalizedStables;\\n      newNormalizerValue = BASE_27;\\n    }\\n    ts.normalizer = newNormalizerValue.toUint128();\\n    if (!increase && ts.normalizedStables == 0) revert CannotBurnAllStableIssued();\\n    emit NormalizerUpdated(newNormalizerValue);\\n  }\\n}\\n\",\"keccak256\":\"0x52467df54a2a68910287c51c0ee42d304de44a7ccacd22fff8426911835356f3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibAuthorization.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\n/// @title LibAuthorization\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Derives the EIP-3009 nonce that binds the Parallelizer's `*WithAuthorization` entry\\n/// points to their full swap/redeem intent (output `to`, slippage, deadline, ...), closing the\\n/// front-running gap left by vanilla `receiveWithAuthorization` which only commits to the token\\n/// transfer itself.\\n/// @dev Off-chain, the authorizer signs a standard EIP-3009 `ReceiveWithAuthorization` with\\n/// `nonce = compute*Nonce(...)`. The facet recomputes the same value from the call arguments and\\n/// forwards it to the token; tampering with any bound field makes the signature invalid. Replay\\n/// protection is provided by the token's own `authorizationStates` mapping; retries use a fresh\\n/// `userSalt`.\\nlibrary LibAuthorization {\\n  // keccak256(\\\"SwapExactInputWithAuthorization(address from,address tokenIn,address tokenOut,uint256 amountIn,uint256\\n  // amountOutMin,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x9be969f74c66b263054aa69cfac8412777a0dc17ab007f81682c6b156ba06d79;\\n\\n  // keccak256(\\\"SwapExactOutputWithAuthorization(address from,address tokenIn,address tokenOut,uint256\\n  // amountOut,uint256 amountInMax,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;\\n\\n  // keccak256(\\\"RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32\\n  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 userSalt)\\\")\\n  bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =\\n    0xcff34e096e1842f6f6ae4c0d0c6eefd4855c8bdc5bc64155d7c14b2dbeee661a;\\n\\n  function computeSwapExactInputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountIn,\\n        amountOutMin,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeSwapExactOutputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountOut,\\n        amountInMax,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeRedeemNonce(\\n    address from,\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        REDEEM_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        amount,\\n        receiver,\\n        deadline,\\n        keccak256(abi.encodePacked(minAmountOuts)),\\n        keccak256(abi.encodePacked(forfeitTokens)),\\n        userSalt\\n      )\\n    );\\n  }\\n}\\n\",\"keccak256\":\"0xe41991a0a564f4f6443aeffd6f1519ae3decc8a9e1e625f51ddf2168453ea4f2\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"CannotBurnAllStableIssued\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotWhitelisted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnexpectedRedemptionTokens\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNormalizerValue\",\"type\":\"uint256\"}],\"name\":\"NormalizerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Redeemed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"quoteRedemptionCurve\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"}],\"name\":\"redeem\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"authData\",\"type\":\"bytes\"}],\"name\":\"redeemWithAuthorization\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"}],\"name\":\"redeemWithForfeit\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"updateNormalizer\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `Redeemer` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"returns\":{\"amounts\":\"Amount that would be obtained for each token in the `tokens` array\",\"tokens\":\"List of tokens that would be given\"}},\"redeem(uint256,address,uint256,uint256[],bytes32)\":{\"details\":\"The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function\",\"params\":{\"deadline\":\"Timestamp before which the redemption should have occured\",\"expectedTokensHash\":\"`keccak256(abi.encodePacked(tokens))` over the output list the caller was quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\",\"minAmountOuts\":\"Minimum amount of each token given back in the redemption to obtain\",\"receiver\":\"Address which should be receiving the output tokens\"},\"returns\":{\"amounts\":\"Amount given for each token in the `tokens` array\",\"tokens\":\"List of tokens returned\"}},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)\":{\"details\":\"The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.`expectedTokensHash` matters most here: a signature stays executable for its whole validity window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)\":{\"details\":\"Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount\"},\"updateNormalizer(uint256,bool)\":{\"details\":\"This function may be called by trusted addresses: these could be for instance savings contract minting stablecoins when they notice a profit\"}},\"title\":\"Redeemer\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"notice\":\"Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\"},\"redeem(uint256,address,uint256,uint256[],bytes32)\":{\"notice\":\"Redeems `amount` of stablecoins from the system\"},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)\":{\"notice\":\"Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)\":{\"notice\":\"Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`.\"},\"updateNormalizer(uint256,bool)\":{\"notice\":\"Updates the normalizer variable by `amount`\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Redeemer.sol\":\"Redeemer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was\\n  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since\\n  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`\\n  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity\\n  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x3362bd4532915b6e2b26b2fdc967a89ea66de5ea5f669d7a621ee69d75c02273\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IEIP3009.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IEIP3009\\n/// @notice Interface for EIP-3009: Transfer With Authorization\\ninterface IEIP3009 {\\n  /// @notice Execute a transfer with a signed authorization (EOA signature)\\n  /// @dev SECURITY: anyone may submit this call (no `msg.sender` restriction). Integrators that\\n  /// pair the transfer with downstream logic (e.g. swap, deposit, redeem) MUST use\\n  /// `receiveWithAuthorization` instead: a mempool watcher can otherwise frontrun the original\\n  /// transaction with a raw `transferWithAuthorization`, burning the nonce so the original\\n  /// reverts while the funds still move - causing the post-transfer logic to be skipped.\\n  /// Use this primitive only for direct payouts to a passive recipient (`msg.sender != to`).\\n  /// @param from The address of the sender\\n  /// @param to The address of the recipient\\n  /// @param value The amount of tokens to transfer\\n  /// @param validAfter The timestamp after which the authorization is valid\\n  /// @param validBefore The timestamp before which the authorization is valid\\n  /// @param nonce The nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Execute a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev SECURITY: see the EOA overload - this primitive is frontrun-prone and must not be used\\n  /// when the transfer is bound to follow-on logic. Use `receiveWithAuthorization` in that case.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EOA signature)\\n  /// @dev The caller must be the payee (`to` address). This has an additional check to ensure\\n  /// that the payee's address matches the caller of this function to prevent front-running attacks.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev The caller must be the payee (`to` address)\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Attempt to cancel an authorization\\n  /// @dev Works only if the authorization is not yet used.\\n  /// EOA wallet signatures should be packed in the order of r, s, v.\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external;\\n\\n  /// @notice Cancel an authorization (EIP-1271 compatible)\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external;\\n\\n  /// @notice Returns the state of an authorization\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @return true if the nonce is used\\n  function authorizationState(address authorizer, bytes32 nonce) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe34cfb584a925054c2e3569c4401c619cd2b928a7b9da04537e71a9089edf55a\",\"license\":\"MIT\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Redeemer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IRedeemer } from \\\"contracts/interfaces/IRedeemer.sol\\\";\\nimport { IEIP3009 } from \\\"contracts/interfaces/external/IEIP3009.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\nimport { LibAuthorization } from \\\"../libraries/LibAuthorization.sol\\\";\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Redeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `Redeemer` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\\ncontract Redeemer is IRedeemer, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  event Redeemed(\\n    uint256 amount,\\n    address[] tokens,\\n    uint256[] amounts,\\n    address[] forfeitTokens,\\n    address indexed from,\\n    address indexed to\\n  );\\n  event NormalizerUpdated(uint256 newNormalizerValue);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev The `minAmountOuts` list must reflect the amount of `tokens` returned\\n  /// @dev In normal conditions, the amount of tokens outputted by this function should be the amount\\n  /// of collateral assets supported by the system, following their order in the `collateralList`.\\n  /// @dev If one collateral has its liquidity managed through strategies, then it's possible that this asset\\n  /// has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption\\n  /// process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral\\n  /// assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering\\n  /// of the token list will be as follows:\\n  /// `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`\\n  /// @dev The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained\\n  /// by calling the `quoteRedemptionCurve` function\\n  /// @dev Tokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the\\n  /// whitelist, otherwise this function reverts\\n  /// @dev No approval is needed before calling this function\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), expectedTokensHash, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token\\n  /// even if it has enough immediately available to send the amount\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev This function may be called by trusted addresses: these could be for instance savings contract\\n  /// minting stablecoins when they notice a profit\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256) {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && s.transmuterStorage().isTrusted[msg.sender] == 0) {\\n      revert NotTrusted();\\n    }\\n    return _updateNormalizer(amount, increase);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    (tokens, amounts,) = _quoteRedemptionCurve(amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Working set passed by reference between `_redeem` and its loop helper, so the call\\n  /// site stays under the EVM stack-depth limit when compiling without via-IR.\\n  struct RedemptionExecution {\\n    uint256 amount;\\n    address from;\\n    address to;\\n    address[] tokens;\\n    uint256[] amounts;\\n    uint256[] subCollateralsTracker;\\n    uint256[] minAmountOuts;\\n    address[] forfeitTokens;\\n  }\\n\\n  /// @notice Internal function of the `redeem` function in the `Redeemer` contract\\n  function _redeem(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    nonReentrant\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    if (s.transmuterStorage().isRedemptionLive == 0) revert Paused();\\n    if (block.timestamp > deadline) revert TooLate();\\n\\n    RedemptionExecution memory redemption;\\n    redemption.amount = amount;\\n    redemption.to = to;\\n    redemption.minAmountOuts = minAmountOuts;\\n    redemption.forfeitTokens = forfeitTokens;\\n\\n    (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);\\n    if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();\\n    // `minAmountOuts` is positional, so it only protects quantities. Binding the output list itself is what\\n    // ties each minimum to the token it was quoted against, across a collateral rotation\\n    if (keccak256(abi.encodePacked(redemption.tokens)) != expectedTokensHash) revert UnexpectedRedemptionTokens();\\n    _updateNormalizer(amount, false);\\n\\n    redemption.from =\\n      _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n\\n    _distributeRedemption(redemption);\\n    emit Redeemed(\\n      redemption.amount,\\n      redemption.tokens,\\n      redemption.amounts,\\n      redemption.forfeitTokens,\\n      redemption.from,\\n      redemption.to\\n    );\\n    return (redemption.tokens, redemption.amounts);\\n  }\\n\\n  /// @notice Releases each non-forfeited collateral output to `redemption.to`. Extracted from `_redeem`\\n  /// so the parent function stays within the EVM stack-depth limit.\\n  function _distributeRedemption(RedemptionExecution memory redemption) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 indexCollateral;\\n    uint256 amountsLength = redemption.amounts.length;\\n    for (uint256 i; i < amountsLength; ++i) {\\n      if (redemption.amounts[i] < redemption.minAmountOuts[i]) revert TooSmallAmountOut();\\n      // If a token is in the `forfeitTokens` list, then it is not sent as part of the redemption process\\n      if (redemption.amounts[i] > 0 && LibHelpers.checkList(redemption.tokens[i], redemption.forfeitTokens) < 0) {\\n        Collateral storage collatInfo = ts.collaterals[collateralListMem[indexCollateral]];\\n        if (collatInfo.onlyWhitelisted > 0 && !LibWhitelist.checkWhitelist(collatInfo.whitelistData, redemption.to)) {\\n          revert NotWhitelisted();\\n        }\\n        if (collatInfo.isManaged > 0) {\\n          LibManager.release(redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config);\\n        } else {\\n          IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);\\n        }\\n      }\\n      if (redemption.subCollateralsTracker[indexCollateral] - 1 <= i) ++indexCollateral;\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer (auth flow) or burns directly from\\n  /// `msg.sender`, and returns the address to attribute the `Redeemed` event to.\\n  function _consumeAuthAndBurn(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    ITokenP tokenP = s.transmuterStorage().tokenP;\\n    if (authData.length > 0) {\\n      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n      tokenP.burnSelf(amount, address(this));\\n    } else {\\n      from = msg.sender;\\n      tokenP.burnSelf(amount, msg.sender);\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer via EIP-3009 `receiveWithAuthorization`,\\n  /// using a derived nonce that binds the full redemption intent.\\n  /// @return from The authorizer address (`params.from`), to attribute the redeem event to\\n  function _executeAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));\\n    if (params.value != amount) revert InvalidSwap();\\n    bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(\\n      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, params.nonce\\n    );\\n    IEIP3009(address(s.transmuterStorage().tokenP))\\n      .receiveWithAuthorization(\\n        params.from, address(this), params.value, params.validAfter, params.validBefore, derivedNonce, params.signature\\n      );\\n    return params.from;\\n  }\\n\\n  /// @dev This function reverts if `stablecoinsIssued==0`, which is expected behavior as there is nothing to redeem\\n  /// anyway in this case, or if the `amountBurnt` is greater than `stablecoinsIssued`\\n  /// @dev Invariant: `penaltyFactor` is evaluated once at the entry-time `collatRatio` and applied uniformly to the\\n  /// full `amountBurnt`. The curve is not path-integrated, so a single redemption that traverses into a lower-penalty\\n  /// segment still pays the entry-time rate on every unit burned. Splitting the same redemption into smaller calls\\n  /// can yield a strictly better blended rate when the path crosses an ascending segment of the curve. This is a\\n  /// deliberate design choice consistent with penalizing early redemptions during under-collateralization; the gap\\n  /// between single-call and path-integrated pricing scales with the ascending-segment slope and should be\\n  /// considered when calibrating `xRedemptionCurve`/`yRedemptionCurve`.\\n  function _quoteRedemptionCurve(uint256 amountBurnt)\\n    internal\\n    view\\n    returns (address[] memory tokens, uint256[] memory balances, uint256[] memory subCollateralsTracker)\\n  {\\n    uint64 collatRatio;\\n    uint256 stablecoinsIssued;\\n    (collatRatio, stablecoinsIssued, tokens, balances, subCollateralsTracker) = LibGetters.getCollateralRatio();\\n    if (amountBurnt >= stablecoinsIssued) revert CannotBurnAllStableIssued();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    int64[] memory yRedemptionCurveMem = ts.yRedemptionCurve;\\n    uint64 penaltyFactor;\\n    // If the protocol is under-collateralized, a penalty factor is applied to the returned amount of each asset\\n    if (collatRatio < BASE_9) {\\n      uint64[] memory xRedemptionCurveMem = ts.xRedemptionCurve;\\n      penaltyFactor = uint64(LibHelpers.piecewiseLinear(collatRatio, xRedemptionCurveMem, yRedemptionCurveMem));\\n    }\\n\\n    for (uint256 i; i < balances.length; ++i) {\\n      // The amount given for each token in reserves does not depend on the price of the tokens in reserve:\\n      // it is a proportion of the balance for each token computed as the ratio between the stablecoins\\n      // burnt relative to the amount of stablecoins issued.\\n      // If the protocol is over-collateralized, the amount of each token given is inversely proportional\\n      // to the collateral ratio.\\n      balances[i] = collatRatio >= BASE_9\\n        ? (amountBurnt * balances[i] * (uint64(yRedemptionCurveMem[yRedemptionCurveMem.length - 1])))\\n          / (stablecoinsIssued * collatRatio)\\n        : (amountBurnt * balances[i] * penaltyFactor) / (stablecoinsIssued * BASE_9);\\n    }\\n  }\\n\\n  /// @notice Updates the `normalizer` variable used to track stablecoins issued from each asset and globally\\n  function _updateNormalizer(uint256 amount, bool increase) internal returns (uint256 newNormalizerValue) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    uint256 _normalizedStables = ts.normalizedStables;\\n    // In case of an increase, the update formula used is the simplified version of the formula below:\\n    /*\\n            _normalizer * (BASE_27 + BASE_27 * amount / stablecoinsIssued) / BASE_27\\n        = _normalizer + (_normalizer * BASE_27 * amount * (BASE_27 / (_normalizedStables * normalizer))) / BASE_27\\n             = _normalizer + BASE_27 * amount / _normalizedStables\\n        */\\n    if (increase) {\\n      newNormalizerValue = _normalizer + (amount * BASE_27) / _normalizedStables;\\n    } else {\\n      newNormalizerValue = _normalizer - (amount * BASE_27) / _normalizedStables;\\n    }\\n    // If the `normalizer` gets too small or too big, it must be renormalized to later avoid the propagation of\\n    // rounding errors, as well as overflows. In this case, the function has to iterate through all the\\n    // supported collateral assets\\n    if (newNormalizerValue <= BASE_18 || newNormalizerValue >= BASE_36) {\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 collateralListLength = collateralListMem.length;\\n      // For each asset, we store the actual amount of stablecoins issued based on the `newNormalizerValue`\\n      // (and not a normalized value)\\n      // We ensure to preserve the invariant `sum(collateralNewNormalizedStables) = normalizedStables`\\n      uint128 newNormalizedStables;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        uint128 newCollateralNormalizedStable = ((uint256(ts.collaterals[collateralListMem[i]].normalizedStables)\\n              * newNormalizerValue) / BASE_27)\\n        .toUint128();\\n        newNormalizedStables += newCollateralNormalizedStable;\\n        ts.collaterals[collateralListMem[i]].normalizedStables = uint216(newCollateralNormalizedStable);\\n      }\\n      ts.normalizedStables = newNormalizedStables;\\n      newNormalizerValue = BASE_27;\\n    }\\n    ts.normalizer = newNormalizerValue.toUint128();\\n    if (!increase && ts.normalizedStables == 0) revert CannotBurnAllStableIssued();\\n    emit NormalizerUpdated(newNormalizerValue);\\n  }\\n}\\n\",\"keccak256\":\"0x1a67602de708b202cbfb4311b65c8e28294c043d059c53c66dcd9c7b1512d3c0\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibAuthorization.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\n/// @title LibAuthorization\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Derives the EIP-3009 nonce that binds the Parallelizer's `*WithAuthorization` entry\\n/// points to their full swap/redeem intent (output `to`, slippage, deadline, ...), closing the\\n/// front-running gap left by vanilla `receiveWithAuthorization` which only commits to the token\\n/// transfer itself.\\n/// @dev Off-chain, the authorizer signs a standard EIP-3009 `ReceiveWithAuthorization` with\\n/// `nonce = compute*Nonce(...)`. The facet recomputes the same value from the call arguments and\\n/// forwards it to the token; tampering with any bound field makes the signature invalid. Replay\\n/// protection is provided by the token's own `authorizationStates` mapping; retries use a fresh\\n/// `userSalt`.\\nlibrary LibAuthorization {\\n  // keccak256(\\\"SwapExactInputWithAuthorization(address from,address tokenIn,address tokenOut,uint256 amountIn,uint256\\n  // amountOutMin,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x9be969f74c66b263054aa69cfac8412777a0dc17ab007f81682c6b156ba06d79;\\n\\n  // keccak256(\\\"SwapExactOutputWithAuthorization(address from,address tokenIn,address tokenOut,uint256\\n  // amountOut,uint256 amountInMax,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;\\n\\n  // keccak256(\\\"RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32\\n  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 expectedTokensHash,bytes32 userSalt)\\\")\\n  bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =\\n    0xb6577f08e668b53303325a19233e8315142d69bedb6d7e1d8d0e9af2473486d4;\\n\\n  function computeSwapExactInputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountIn,\\n        amountOutMin,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeSwapExactOutputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountOut,\\n        amountInMax,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the redemption output list the\\n  /// authorizer was quoted, binding token identity and ordering rather than raw amounts alone\\n  function computeRedeemNonce(\\n    address from,\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        REDEEM_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        amount,\\n        receiver,\\n        deadline,\\n        keccak256(abi.encodePacked(minAmountOuts)),\\n        keccak256(abi.encodePacked(forfeitTokens)),\\n        expectedTokensHash,\\n        userSalt\\n      )\\n    );\\n  }\\n}\\n\",\"keccak256\":\"0x195b02224ec034756820857b7f88acc6ace194d00a68a9a6f0bcb8adf38963c8\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -407,13 +428,13 @@
       "quoteRedemptionCurve(uint256)": {
         "notice": "Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block"
       },
-      "redeem(uint256,address,uint256,uint256[])": {
+      "redeem(uint256,address,uint256,uint256[],bytes32)": {
         "notice": "Redeems `amount` of stablecoins from the system"
       },
-      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": {
+      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": {
         "notice": "Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer."
       },
-      "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": {
+      "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": {
         "notice": "Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`."
       },
       "updateNormalizer(uint256,bool)": {
@@ -424,13 +445,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0xacd73e1f5740801b5ad328440c036aa34088508b704873474600ab6e15c79bfc",
-    "nonce": "0xc7",
+    "hash": "0x9353db33ba248005a23c46a3277a91ba7126449c13f5024b01edec342831fd8c",
+    "nonce": "0xe1",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
-    "blockHash": "0xa03c27fb23ea54408e37202102110b578f8162d89b79c6cd53a6cb961e28a3c0",
-    "blockNumber": "0x56e29e4",
-    "transactionIndex": "0x2"
+    "blockHash": "0xded6958adedbadbf9ac309ef54f73747b11700f307bc306c8ad6a2d93f7d900d",
+    "blockNumber": "0x5c76698",
+    "transactionIndex": "0x0"
   }
 }
\ No newline at end of file
diff --git a/deployments/avalanche/RewardHandler.json b/deployments/avalanche/RewardHandler.json
index 4632066..0294b74 100644
--- a/deployments/avalanche/RewardHandler.json
+++ b/deployments/avalanche/RewardHandler.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x9d4a036cb8823f91e80eaac39295a1a302ca5f9f",
+  "address": "0x4731f7c0a3b670f78ccb2e3620ae636465ca5279",
   "abi": [
     {
       "inputs": [],
@@ -18,12 +18,12 @@
     },
     {
       "inputs": [],
-      "name": "OdosSwapFailed",
+      "name": "ReentrantCall",
       "type": "error"
     },
     {
       "inputs": [],
-      "name": "ReentrantCall",
+      "name": "RewardSwapFailed",
       "type": "error"
     },
     {
@@ -42,6 +42,11 @@
       "name": "TooSmallAmountOut",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -88,8 +93,8 @@
   ],
   "contractName": "RewardHandler",
   "sourceName": "contracts/parallelizer/facets/RewardHandler.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -108,7 +113,7 @@
     "kind": "dev",
     "methods": {
       "sellRewards(uint256,bytes)": {
-        "details": "It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to Odos router for the token to be swapped"
+        "details": "It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to the configured `swapRouter` for the token to be swapped"
       }
     },
     "title": "RewardHandler",
@@ -117,9 +122,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "800000",
-        "executionCost": "829",
-        "totalCost": "800829"
+        "codeDepositCost": "810200",
+        "executionCost": "842",
+        "totalCost": "811042"
       },
       "external": {
         "sellRewards(uint256,bytes)": "infinite"
@@ -129,7 +134,7 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokens\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OdosSwapFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenObtained\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"balanceUpdate\",\"type\":\"uint256\"}],\"name\":\"RewardsSoldFor\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"sellRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `RewardHandler` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"details\":\"It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to Odos router for the token to be swapped\"}},\"title\":\"RewardHandler\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"notice\":\"IRewardHandler\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/RewardHandler.sol\":\"RewardHandler\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/RewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { IRewardHandler } from \\\"contracts/interfaces/IRewardHandler.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title RewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `RewardHandler` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\\ncontract RewardHandler is IRewardHandler, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n\\n  event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);\\n\\n  /// @notice IRewardHandler\\n  /// @dev It is impossible to sell a token that is a collateral through this function\\n  /// @dev Trusted sellers and governance only may call this function\\n  /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval\\n  /// transaction to Odos router for the token to be swapped\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    address[] memory list = ts.collateralList;\\n    uint256 listLength = list.length;\\n    uint256[] memory balances = new uint256[](listLength);\\n    // Getting the balances of all collateral assets of the protocol to see if those do not decrease during\\n    // the swap: this is the only way to check that collateral assets have not been sold\\n    // Not checking the `subCollaterals` here as swaps should try to increase the balance of one collateral\\n    for (uint256 i; i < listLength; ++i) {\\n      balances[i] = IERC20(list[i]).balanceOf(address(this));\\n    }\\n    uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));\\n    //solhint-disable-next-line\\n    (bool success, bytes memory result) = ODOS_ROUTER.call(payload);\\n    if (!success) _revertBytes(result);\\n    if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();\\n    bool hasIncreased;\\n    address collateral;\\n    for (uint256 i; i < listLength; ++i) {\\n      uint256 newBalance = IERC20(list[i]).balanceOf(address(this));\\n      if (newBalance < balances[i]) {\\n        revert InvalidSwap();\\n      } else if (newBalance > balances[i]) {\\n        hasIncreased = true;\\n        collateral = list[i];\\n        amountOut = newBalance - balances[i];\\n        if (amountOut < minAmountOut) revert TooSmallAmountOut();\\n        emit RewardsSoldFor(collateral, amountOut);\\n      }\\n    }\\n    if (!hasIncreased) revert InvalidSwap();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      IERC20(collateral).safeTransfer(LibManager.transferRecipient(collatInfo.managerData.config), amountOut);\\n      LibManager.invest(amountOut, collatInfo.managerData.config);\\n    }\\n  }\\n\\n  /// @notice Processes odos revert messages\\n  function _revertBytes(bytes memory errMsg) private pure {\\n    if (errMsg.length > 0) {\\n      //solhint-disable-next-line\\n      assembly (\\\"memory-safe\\\") {\\n        revert(add(32, errMsg), mload(errMsg))\\n      }\\n    }\\n    revert OdosSwapFailed();\\n  }\\n}\\n\",\"keccak256\":\"0xf01917011b3966f1783fa024ce6c56b5294ef0f65531bdc3f2e068649cd45038\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokens\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RewardSwapFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenObtained\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"balanceUpdate\",\"type\":\"uint256\"}],\"name\":\"RewardsSoldFor\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"sellRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `RewardHandler` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"details\":\"It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to the configured `swapRouter` for the token to be swapped\"}},\"title\":\"RewardHandler\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"notice\":\"IRewardHandler\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/RewardHandler.sol\":\"RewardHandler\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a call to the configured swap router\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to the swap router\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xb3604f35c5bb44791020588e00774299a6a4adae17d62d1e53cd8be86da6b709\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/RewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { IRewardHandler } from \\\"contracts/interfaces/IRewardHandler.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title RewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `RewardHandler` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\\ncontract RewardHandler is IRewardHandler, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n\\n  event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);\\n\\n  /// @notice IRewardHandler\\n  /// @dev It is impossible to sell a token that is a collateral through this function\\n  /// @dev Trusted sellers and governance only may call this function\\n  /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval\\n  /// transaction to the configured `swapRouter` for the token to be swapped\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    address[] memory list = ts.collateralList;\\n    uint256 listLength = list.length;\\n    uint256[] memory balances = new uint256[](listLength);\\n    // Getting the balances of all collateral assets of the protocol to see if those do not decrease during\\n    // the swap: this is the only way to check that collateral assets have not been sold\\n    // Not checking the `subCollaterals` here as swaps should try to increase the balance of one collateral\\n    for (uint256 i; i < listLength; ++i) {\\n      balances[i] = IERC20(list[i]).balanceOf(address(this));\\n    }\\n    uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));\\n    address swapRouter = ts.swapRouter;\\n    if (swapRouter == address(0)) revert ZeroAddress();\\n    //solhint-disable-next-line\\n    (bool success, bytes memory result) = swapRouter.call(payload);\\n    if (!success) _revertBytes(result);\\n    if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();\\n    bool hasIncreased;\\n    address collateral;\\n    for (uint256 i; i < listLength; ++i) {\\n      uint256 newBalance = IERC20(list[i]).balanceOf(address(this));\\n      if (newBalance < balances[i]) {\\n        revert InvalidSwap();\\n      } else if (newBalance > balances[i]) {\\n        hasIncreased = true;\\n        collateral = list[i];\\n        amountOut = newBalance - balances[i];\\n        if (amountOut < minAmountOut) revert TooSmallAmountOut();\\n        emit RewardsSoldFor(collateral, amountOut);\\n      }\\n    }\\n    if (!hasIncreased) revert InvalidSwap();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      IERC20(collateral).safeTransfer(LibManager.transferRecipient(collatInfo.managerData.config), amountOut);\\n      LibManager.invest(amountOut, collatInfo.managerData.config);\\n    }\\n  }\\n\\n  /// @notice Processes the router's revert messages\\n  function _revertBytes(bytes memory errMsg) private pure {\\n    if (errMsg.length > 0) {\\n      //solhint-disable-next-line\\n      assembly (\\\"memory-safe\\\") {\\n        revert(add(32, errMsg), mload(errMsg))\\n      }\\n    }\\n    revert RewardSwapFailed();\\n  }\\n}\\n\",\"keccak256\":\"0xa4e2fdeaaa43d78dfe1a81f458108856ebc92f27a7194e6293ac3c5084325beb\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -145,13 +150,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0xea0100366ae27eb0dd8165d7bb8b98efb15a8a06d200f0e02ab04dfe3ad4704d",
-    "nonce": "0xc8",
+    "hash": "0x5bdae46acb4d5290b3abc2c1d51e0f6c1d0e257235d33dee1b55278718b30261",
+    "nonce": "0xe2",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
-    "blockHash": "0x9d83f9a0db2d0682390aba664cb2c1217b732fc9391978f1fc7fab07883afb07",
-    "blockNumber": "0x56e29e6",
+    "blockHash": "0x298dfd62dae749105c12cfbea3402c63ae39c9b0c45d34b230e64430109b507a",
+    "blockNumber": "0x5c7669a",
     "transactionIndex": "0x1"
   }
 }
\ No newline at end of file
diff --git a/deployments/avalanche/SettersGovernor.json b/deployments/avalanche/SettersGovernor.json
index 91507d7..6145cbf 100644
--- a/deployments/avalanche/SettersGovernor.json
+++ b/deployments/avalanche/SettersGovernor.json
@@ -1,5 +1,5 @@
 {
-  "address": "0xe9b09cc151fcc7f6a1347098ed305b02f46b17b8",
+  "address": "0xbef8dd3e729a081855ae7a5fcc5b6373f75d1ba9",
   "abi": [
     {
       "inputs": [],
@@ -57,6 +57,11 @@
       "name": "InvalidParams",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "InvalidPayee",
+      "type": "error"
+    },
     {
       "inputs": [],
       "name": "InvalidRate",
@@ -135,6 +140,11 @@
       "name": "SafeERC20FailedOperation",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
     {
       "inputs": [],
       "name": "ZeroAmount",
@@ -285,6 +295,31 @@
       "name": "OracleSet",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "collateral",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "previousTarget",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "newTarget",
+          "type": "uint256"
+        }
+      ],
+      "name": "OracleTargetUpdated",
+      "type": "event"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -405,6 +440,19 @@
       "name": "SurplusBufferRatioUpdated",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "swapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "SwapRouterUpdated",
+      "type": "event"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -601,6 +649,19 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "swapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "setSwapRouter",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -712,8 +773,8 @@
   ],
   "contractName": "SettersGovernor",
   "sourceName": "contracts/parallelizer/facets/SettersGovernor.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -759,6 +820,9 @@
       "setCollateralManager(address,bool,(address[],bytes))": {
         "details": "Funds need to have been withdrawn from the eventual previous manager prior to this call"
       },
+      "setSwapRouter(address)": {
+        "details": "The payload is executed with a raw call, so any router can be configured. It is chain specific and must be set on every deployment before rewards can be sold"
+      },
       "updatePayees(address[],uint256[],bool)": {
         "params": {
           "_payees": "The new payee addresses",
@@ -782,9 +846,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "3353000",
-        "executionCost": "3729",
-        "totalCost": "3356729"
+        "codeDepositCost": "3440800",
+        "executionCost": "3842",
+        "totalCost": "3444642"
       },
       "external": {
         "addCollateral(address)": "infinite",
@@ -795,6 +859,7 @@
         "setAccessManager(address)": "infinite",
         "setCollateralManager(address,bool,(address[],bytes))": "infinite",
         "setOracle(address,bytes)": "infinite",
+        "setSwapRouter(address)": "infinite",
         "setWhitelistStatus(address,uint8,bytes)": "infinite",
         "toggleTrusted(address,uint8)": "infinite",
         "updateOracle(address)": "infinite",
@@ -804,12 +869,17 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AboveCap\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyAdded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CollateralBacked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccessManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParams\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidWhitelistStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ManagerHasAssets\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OracleUpdateFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentAllowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requestedDecrease\",\"type\":\"uint256\"}],\"name\":\"SafeERC20FailedDecreaseAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"indexed\":false,\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"CollateralManagerSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"}],\"name\":\"CollateralWhitelistStatusUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleasedToPayee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"OracleSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"PayeeAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"ReservesAdjusted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"SlippageToleranceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"SurplusBufferRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isTrusted\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"enum TrustedType\",\"name\":\"trustedType\",\"type\":\"uint8\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"addCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"adjustStablecoins\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"changeAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"}],\"name\":\"revokeCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAccessManager\",\"type\":\"address\"}],\"name\":\"setAccessManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"setCollateralManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"setOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"}],\"name\":\"setWhitelistStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"enum TrustedType\",\"name\":\"t\",\"type\":\"uint8\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"updateOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_payees\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_shares\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"_skipRelease\",\"type\":\"bool\"}],\"name\":\"updatePayees\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"updateSlippageTolerance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"updateSurplusBufferRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `SettersGovernor` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedDecreaseAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failed `decreaseAllowance` request.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"addCollateral(address)\":{\"details\":\"Collateral assets with a fee on transfer are not supported by the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"details\":\"The amount passed here must be an absolute amount\"},\"changeAllowance(address,address,uint256)\":{\"details\":\"This function can typically be used to grant allowance to a newly added manager for it to pull the funds associated to the collateral it corresponds to\"},\"recoverERC20(address,address,address,uint256)\":{\"details\":\"No check is made on the collateral that is redeemed: this function could typically be used by a governance during a manual rebalance of the reserves of the system`collateral` is different from `token` only in the case of a managed collateral\"},\"revokeCollateral(address,bool)\":{\"details\":\"Require `collatInfo.normalizedStables == 0`, that is to say that the collateral is not used to back stablesThe system may still have a non null balance of the collateral that is revoked: this should later be handled through a recoverERC20 callFunds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is true\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"details\":\"Funds need to have been withdrawn from the eventual previous manager prior to this call\"},\"updatePayees(address[],uint256[],bool)\":{\"params\":{\"_payees\":\"The new payee addresses\",\"_shares\":\"The new shares for each payee\",\"_skipRelease\":\"If true, skips the automatic income release before updating\"}},\"updateSlippageTolerance(address,uint256)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when calling the `processSurplus` function\"},\"updateSurplusBufferRatio(uint64)\":{\"details\":\"The surplus buffer ratio is the minimum collateral ratio required after surplus processing\",\"params\":{\"_surplusBufferRatio\":\"The new surplus buffer ratio in BASE_9\"}}},\"title\":\"SettersGovernor\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addCollateral(address)\":{\"notice\":\"Add `collateral` as a supported collateral in the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"notice\":\"Adjusts the amount of stablecoins issued from `collateral` by `amount`\"},\"changeAllowance(address,address,uint256)\":{\"notice\":\"Sets the allowance of the contract on `token` for `spender` to `amount`\"},\"recoverERC20(address,address,address,uint256)\":{\"notice\":\"Recovers `amount` of `token` from the Parallelizer contract\"},\"revokeCollateral(address,bool)\":{\"notice\":\"Revokes `collateral` from the system\"},\"setAccessManager(address)\":{\"notice\":\"Sets a new access manager address\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"notice\":\"Sets (or unsets) a collateral manager  `collateral`\"},\"setOracle(address,bytes)\":{\"notice\":\"Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations\"},\"setWhitelistStatus(address,uint8,bytes)\":{\"notice\":\"Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist\"},\"toggleTrusted(address,uint8)\":{\"notice\":\"Changes the trusted status for `sender` when for selling rewards or updating the normalizer\"},\"updateOracle(address)\":{\"notice\":\"Update oracle data for a given `collateral`\"},\"updatePayees(address[],uint256[],bool)\":{\"notice\":\"Updates the payees and their shares\"},\"updateSlippageTolerance(address,uint256)\":{\"notice\":\"Updates the slippage tolerance for a `collateral`\"},\"updateSurplusBufferRatio(uint64)\":{\"notice\":\"Updates the surplus buffer ratio\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/SettersGovernor.sol\":\"SettersGovernor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xd4d195b62841c28dd5f248d09e682c3c81bda24b471cd8a5d8efe498519ea50d\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/SettersGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { ISettersGovernor } from \\\"contracts/interfaces/ISetters.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibSetters } from \\\"../libraries/LibSetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title SettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\\ncontract SettersGovernor is AccessManagedModifiers, ISettersGovernor {\\n  using SafeERC20 for IERC20;\\n\\n  event Recovered(address indexed token, address indexed to, uint256 amount);\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev No check is made on the collateral that is redeemed: this function could typically be used by a\\n  /// governance during a manual rebalance of the reserves of the system\\n  /// @dev `collateral` is different from `token` only in the case of a managed collateral\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);\\n    else token.safeTransfer(to, amount);\\n    emit Recovered(address(token), to, amount);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setAccessManager(address _newAccessManager) external restricted {\\n    LibSetters.setAccessManager(IAccessManager(_newAccessManager));\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the\\n  /// funds associated to the collateral it corresponds to\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {\\n    uint256 currentAllowance = token.allowance(address(this), spender);\\n    if (currentAllowance < amount) {\\n      token.safeIncreaseAllowance(spender, amount - currentAllowance);\\n    } else if (currentAllowance > amount) {\\n      token.safeDecreaseAllowance(spender, currentAllowance - amount);\\n    }\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function toggleTrusted(address sender, TrustedType t) external restricted {\\n    LibSetters.toggleTrusted(sender, t);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Collateral assets with a fee on transfer are not supported by the system\\n  function addCollateral(address collateral) external restricted {\\n    LibSetters.addCollateral(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev The amount passed here must be an absolute amount\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {\\n    LibSetters.adjustStablecoins(collateral, amount, increase);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral\\n  /// is not used to back stables\\n  /// @dev The system may still have a non null balance of the collateral that is revoked: this should later\\n  /// be handled through a recoverERC20 call\\n  /// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is\\n  /// true\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {\\n    LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setOracle(address collateral, bytes memory oracleConfig) external restricted {\\n    LibSetters.setOracle(collateral, oracleConfig);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateOracle(address collateral) external {\\n    if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    LibOracle.updateOracle(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setWhitelistStatus(\\n    address collateral,\\n    uint8 whitelistStatus,\\n    bytes memory whitelistData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external restricted {\\n    LibSetters.updatePayees(_payees, _shares, _skipRelease);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external restricted {\\n    LibSetters.updateSlippageTolerance(collateral, slippageTolerance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {\\n    LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);\\n  }\\n}\\n\",\"keccak256\":\"0x3d0d0351ef8f06a401c421d2f76b4227e4819935583ad29f44fc6dc59f5ea021\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport { LibSurplus } from \\\"./LibSurplus.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { LibDiamond } from \\\"./LibDiamond.sol\\\";\\nimport { LibWhitelist } from \\\"./LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibSetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibSetters.sol\\nlibrary LibSetters {\\n  using SafeCast for uint256;\\n\\n  event CollateralAdded(address indexed collateral);\\n  event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);\\n  event CollateralRevoked(address indexed collateral);\\n  event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);\\n  event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);\\n  event OracleSet(address indexed collateral, bytes oracleConfig);\\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n  event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);\\n  event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);\\n  event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);\\n  event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);\\n  event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);\\n  event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);\\n  event PayeeAdded(address indexed payee, uint256 shares);\\n  event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);\\n  event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GOVERNOR ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `setAccessManager`\\n  function setAccessManager(IAccessManager _newAccessManager) internal {\\n    if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();\\n    DiamondStorage storage ds = s.diamondStorage();\\n    address previousAccessManager = address(ds.accessManager);\\n    ds.accessManager = _newAccessManager;\\n    emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));\\n  }\\n\\n  /// @notice Internal version of `setCollateralManager`\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    internal\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    if (managerData.config.length != 0) {\\n      // The first subCollateral given should be the actual collateral asset\\n      if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();\\n      // Sanity check on the manager data that is passed\\n      LibManager.parseManagerConfig(managerData.config);\\n      collatInfo.isManaged = 1;\\n    } else {\\n      collatInfo.isManaged = 0;\\n    }\\n    collatInfo.managerData = managerData;\\n    emit CollateralManagerSet(collateral, managerData);\\n  }\\n\\n  /// @notice Internal version of `toggleTrusted`\\n  function toggleTrusted(address sender, TrustedType t) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 trustedStatus;\\n    if (t == TrustedType.Updater) {\\n      trustedStatus = 1 - ts.isTrusted[sender];\\n      ts.isTrusted[sender] = trustedStatus;\\n    } else {\\n      trustedStatus = 1 - ts.isSellerTrusted[sender];\\n      ts.isSellerTrusted[sender] = trustedStatus;\\n    }\\n    emit TrustedToggled(sender, trustedStatus == 1, t);\\n  }\\n\\n  /// @notice Internal version of `addCollateral`\\n  function addCollateral(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals != 0) revert AlreadyAdded();\\n    collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());\\n    ts.collateralList.push(collateral);\\n    emit CollateralAdded(collateral);\\n  }\\n\\n  /// @notice Internal version of `adjustStablecoins`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();\\n    if (increase) {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables + normalizedAmount;\\n      if (uint256(collatInfo.normalizedStables) * uint256(ts.normalizer) / BASE_27 > collatInfo.stablecoinCap) {\\n        revert AboveCap();\\n      }\\n    } else {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables - normalizedAmount;\\n    }\\n    emit ReservesAdjusted(collateral, amount, increase);\\n  }\\n\\n  /// @notice Internal version of `revokeCollateral`\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (collatInfo.normalizedStables > 0) revert CollateralBacked();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    delete ts.collaterals[collateral];\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 length = collateralListMem.length;\\n    for (uint256 i; i < length - 1; ++i) {\\n      if (collateralListMem[i] == collateral) {\\n        ts.collateralList[i] = collateralListMem[length - 1];\\n        break;\\n      }\\n    }\\n    ts.collateralList.pop();\\n    emit CollateralRevoked(collateral);\\n  }\\n\\n  /// @notice Internal version of `setOracle`\\n  function setOracle(address collateral, bytes memory oracleConfig) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    (,,,, bytes memory hyperparameters) =\\n      abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    if (userDeviation > burnRatioDeviation) revert InvalidParams();\\n    // Checks oracle validity\\n    LibOracle.readMint(oracleConfig);\\n    collatInfo.oracleConfig = oracleConfig;\\n    emit OracleSet(collateral, oracleConfig);\\n  }\\n\\n  /// @notice Internal version of `setWhitelistStatus`\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {\\n    if (whitelistStatus > 1) revert InvalidWhitelistStatus();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (whitelistStatus == 1) {\\n      // Sanity check\\n      LibWhitelist.checkWhitelist(whitelistData, address(this));\\n      collatInfo.whitelistData = whitelistData;\\n    } else {\\n      // If whitelist is revoked, clear the whitelist data\\n      collatInfo.whitelistData = \\\"\\\";\\n    }\\n    collatInfo.onlyWhitelisted = whitelistStatus;\\n    emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GUARDIAN ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `pause` \\u2014 sets the action's live flag to `0`\\n  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance\\n  /// call cannot pass silently\\n  function pause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 0);\\n  }\\n\\n  /// @notice Internal version of `unpause` \\u2014 sets the action's live flag to `1`\\n  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance\\n  /// call cannot pass silently\\n  function unpause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 1);\\n  }\\n\\n  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`\\n  /// to unpause. Reverts on no-op transitions.\\n  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;\\n      if (currentIsLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      if (action == ActionType.Mint) {\\n        collatInfo.isMintLive = targetIsLive;\\n      } else {\\n        collatInfo.isBurnLive = targetIsLive;\\n      }\\n    } else {\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      if (ts.isRedemptionLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      ts.isRedemptionLive = targetIsLive;\\n    }\\n    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);\\n  }\\n\\n  /// @notice Internal version of `setFees`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);\\n    if (mint) {\\n      collatInfo.xFeeMint = xFee;\\n      collatInfo.yFeeMint = yFee;\\n    } else {\\n      collatInfo.xFeeBurn = xFee;\\n      collatInfo.yFeeBurn = yFee;\\n    }\\n    emit FeesSet(collateral, xFee, yFee, mint);\\n  }\\n\\n  /// @notice Internal version of `setRedemptionCurveParams`\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    LibSetters.checkFees(xFee, yFee, ActionType.Redeem);\\n    ts.xRedemptionCurve = xFee;\\n    ts.yRedemptionCurve = yFee;\\n    emit RedemptionCurveParamsSet(xFee, yFee);\\n  }\\n\\n  /// @notice Internal version of `toggleWhitelist`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];\\n    ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;\\n    emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);\\n  }\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a collateral\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    collatInfo.stablecoinCap = stablecoinCap;\\n    emit StablecoinCapSet(collateral, stablecoinCap);\\n  }\\n\\n  /// @notice Internal version of `updatePayees`\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) internal {\\n    if (_payees.length == 0 || _payees.length > MAX_PAYEES) revert InvalidLengths();\\n    if (_payees.length != _shares.length) revert ArrayLengthMismatch();\\n    /// @dev Distribute the fees before updating the fee receivers.\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!_skipRelease) {\\n      uint256 income = ts.tokenP.balanceOf(address(this));\\n      if (income > 0 && ts.payees.length > 0) {\\n        LibSurplus.release(income, ts.payees);\\n      }\\n    }\\n\\n    // Zero out stale shares for old payees\\n    uint256 i = 0;\\n    for (; i < ts.payees.length; ++i) {\\n      ts.shares[ts.payees[i]] = 0;\\n    }\\n    delete ts.payees;\\n    uint256 _totalShares = 0;\\n    i = 0;\\n    for (; i < _payees.length; ++i) {\\n      for (uint256 j = 0; j < i; ++j) {\\n        if (_payees[j] == _payees[i]) revert AlreadyAdded();\\n      }\\n      _totalShares += _addPayee(_payees[i], _shares[i]);\\n    }\\n    ts.totalShares = _totalShares;\\n  }\\n\\n  /// @notice Internal version of `updateSlippageTolerance`\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) internal {\\n    if (slippageTolerance > BASE_9) revert InvalidRate();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.slippageTolerance[collateral] = slippageTolerance;\\n    emit SlippageToleranceUpdated(collateral, slippageTolerance);\\n  }\\n\\n  /// @notice Internal version of `updateSurplusBufferRatio`\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {\\n    if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.surplusBufferRatio = _surplusBufferRatio;\\n    emit SurplusBufferRatioUpdated(_surplusBufferRatio);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions\\n  function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {\\n    uint256 n = xFee.length;\\n    if (n != yFee.length || n == 0) revert InvalidParams();\\n    if (\\n      // Mint inflexion points should be in [0,BASE_9[\\n      // We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9\\n      // Hence we consider BASE_12 as the max value (100% fees) for yFeeMint\\n      // Burn inflexion points should be in [0,BASE_9] but fees should be constant in\\n      // the first segment [BASE_9, x_{n-1}[\\n      // Redemption inflexion points should be in [0,BASE_9]\\n      (action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))\\n        || (action == ActionType.Burn\\n          && (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1]))))\\n        || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))\\n    ) {\\n      revert InvalidParams();\\n    }\\n\\n    for (uint256 i; i < n - 1; ++i) {\\n      if (\\n        // xFee strictly increasing and yFee increasing for mints\\n        // xFee strictly decreasing and yFee increasing for burns\\n        // xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions\\n        (action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))\\n      ) revert InvalidParams();\\n    }\\n\\n    // If a mint or burn fee is negative, we need to check that accounts atomically minting\\n    // (from any collateral) and then burning cannot get more than their initial value\\n    if (yFee[0] < 0) {\\n      if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 length = collateralListMem.length;\\n      if (action == ActionType.Mint) {\\n        // This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;\\n          if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n      if (action == ActionType.Burn) {\\n        // This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;\\n          if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n    }\\n  }\\n\\n  /// @notice Add a new fee receiver.\\n  /// @param _payee The address of the fee receiver.\\n  /// @param _shares The number of shares assigned to the fee receiver.\\n  function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {\\n    if (_shares == 0) revert ZeroAmount();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n\\n    ts.payees.push(_payee);\\n    ts.shares[_payee] = _shares;\\n    emit PayeeAdded(_payee, _shares);\\n    return _shares;\\n  }\\n}\\n\",\"keccak256\":\"0x9e41915e7fb03ef3b054f7ce0b7ab297e3b8f5c05ab1e7ebe072e22f11b22362\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AboveCap\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyAdded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CollateralBacked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccessManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParams\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidPayee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidWhitelistStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ManagerHasAssets\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OracleUpdateFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentAllowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requestedDecrease\",\"type\":\"uint256\"}],\"name\":\"SafeERC20FailedDecreaseAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"indexed\":false,\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"CollateralManagerSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"}],\"name\":\"CollateralWhitelistStatusUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleasedToPayee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"OracleSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"previousTarget\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newTarget\",\"type\":\"uint256\"}],\"name\":\"OracleTargetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"PayeeAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"ReservesAdjusted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"SlippageToleranceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"SurplusBufferRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"swapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isTrusted\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"enum TrustedType\",\"name\":\"trustedType\",\"type\":\"uint8\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"addCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"adjustStablecoins\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"changeAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"}],\"name\":\"revokeCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAccessManager\",\"type\":\"address\"}],\"name\":\"setAccessManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"setCollateralManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"setOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"swapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"}],\"name\":\"setWhitelistStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"enum TrustedType\",\"name\":\"t\",\"type\":\"uint8\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"updateOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_payees\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_shares\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"_skipRelease\",\"type\":\"bool\"}],\"name\":\"updatePayees\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"updateSlippageTolerance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"updateSurplusBufferRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `SettersGovernor` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedDecreaseAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failed `decreaseAllowance` request.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"addCollateral(address)\":{\"details\":\"Collateral assets with a fee on transfer are not supported by the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"details\":\"The amount passed here must be an absolute amount\"},\"changeAllowance(address,address,uint256)\":{\"details\":\"This function can typically be used to grant allowance to a newly added manager for it to pull the funds associated to the collateral it corresponds to\"},\"recoverERC20(address,address,address,uint256)\":{\"details\":\"No check is made on the collateral that is redeemed: this function could typically be used by a governance during a manual rebalance of the reserves of the system`collateral` is different from `token` only in the case of a managed collateral\"},\"revokeCollateral(address,bool)\":{\"details\":\"Require `collatInfo.normalizedStables == 0`, that is to say that the collateral is not used to back stablesThe system may still have a non null balance of the collateral that is revoked: this should later be handled through a recoverERC20 callFunds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is true\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"details\":\"Funds need to have been withdrawn from the eventual previous manager prior to this call\"},\"setSwapRouter(address)\":{\"details\":\"The payload is executed with a raw call, so any router can be configured. It is chain specific and must be set on every deployment before rewards can be sold\"},\"updatePayees(address[],uint256[],bool)\":{\"params\":{\"_payees\":\"The new payee addresses\",\"_shares\":\"The new shares for each payee\",\"_skipRelease\":\"If true, skips the automatic income release before updating\"}},\"updateSlippageTolerance(address,uint256)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when calling the `processSurplus` function\"},\"updateSurplusBufferRatio(uint64)\":{\"details\":\"The surplus buffer ratio is the minimum collateral ratio required after surplus processing\",\"params\":{\"_surplusBufferRatio\":\"The new surplus buffer ratio in BASE_9\"}}},\"title\":\"SettersGovernor\",\"version\":1},\"userdoc\":{\"events\":{\"OracleTargetUpdated(address,uint256,uint256)\":{\"notice\":\"Emitted when a MAX target price is ratcheted up by `updateOracle`\"}},\"kind\":\"user\",\"methods\":{\"addCollateral(address)\":{\"notice\":\"Add `collateral` as a supported collateral in the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"notice\":\"Adjusts the amount of stablecoins issued from `collateral` by `amount`\"},\"changeAllowance(address,address,uint256)\":{\"notice\":\"Sets the allowance of the contract on `token` for `spender` to `amount`\"},\"recoverERC20(address,address,address,uint256)\":{\"notice\":\"Recovers `amount` of `token` from the Parallelizer contract\"},\"revokeCollateral(address,bool)\":{\"notice\":\"Revokes `collateral` from the system\"},\"setAccessManager(address)\":{\"notice\":\"Sets a new access manager address\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"notice\":\"Sets (or unsets) a collateral manager  `collateral`\"},\"setOracle(address,bytes)\":{\"notice\":\"Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations\"},\"setSwapRouter(address)\":{\"notice\":\"Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\"},\"setWhitelistStatus(address,uint8,bytes)\":{\"notice\":\"Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist\"},\"toggleTrusted(address,uint8)\":{\"notice\":\"Changes the trusted status for `sender` when for selling rewards or updating the normalizer\"},\"updateOracle(address)\":{\"notice\":\"Update oracle data for a given `collateral`\"},\"updatePayees(address[],uint256[],bool)\":{\"notice\":\"Updates the payees and their shares\"},\"updateSlippageTolerance(address,uint256)\":{\"notice\":\"Updates the slippage tolerance for a `collateral`\"},\"updateSurplusBufferRatio(uint64)\":{\"notice\":\"Updates the surplus buffer ratio\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/SettersGovernor.sol\":\"SettersGovernor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n\\n  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain\\n  /// specific and must be set on every deployment before rewards can be sold\\n  function setSwapRouter(address swapRouter) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xe62d2880420afb053498b01f1def17d4c8e2c6c9b48cc5a71d013150a5ca8db4\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/SettersGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { ISettersGovernor } from \\\"contracts/interfaces/ISetters.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibSetters } from \\\"../libraries/LibSetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title SettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\\ncontract SettersGovernor is AccessManagedModifiers, ISettersGovernor {\\n  using SafeERC20 for IERC20;\\n\\n  event Recovered(address indexed token, address indexed to, uint256 amount);\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev No check is made on the collateral that is redeemed: this function could typically be used by a\\n  /// governance during a manual rebalance of the reserves of the system\\n  /// @dev `collateral` is different from `token` only in the case of a managed collateral\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);\\n    else token.safeTransfer(to, amount);\\n    emit Recovered(address(token), to, amount);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setAccessManager(address _newAccessManager) external restricted {\\n    LibSetters.setAccessManager(IAccessManager(_newAccessManager));\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the\\n  /// funds associated to the collateral it corresponds to\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {\\n    uint256 currentAllowance = token.allowance(address(this), spender);\\n    if (currentAllowance < amount) {\\n      token.safeIncreaseAllowance(spender, amount - currentAllowance);\\n    } else if (currentAllowance > amount) {\\n      token.safeDecreaseAllowance(spender, currentAllowance - amount);\\n    }\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function toggleTrusted(address sender, TrustedType t) external restricted {\\n    LibSetters.toggleTrusted(sender, t);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Collateral assets with a fee on transfer are not supported by the system\\n  function addCollateral(address collateral) external restricted {\\n    LibSetters.addCollateral(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev The amount passed here must be an absolute amount\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {\\n    LibSetters.adjustStablecoins(collateral, amount, increase);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral\\n  /// is not used to back stables\\n  /// @dev The system may still have a non null balance of the collateral that is revoked: this should later\\n  /// be handled through a recoverERC20 call\\n  /// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is\\n  /// true\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {\\n    LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setOracle(address collateral, bytes memory oracleConfig) external restricted {\\n    LibSetters.setOracle(collateral, oracleConfig);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateOracle(address collateral) external {\\n    if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    LibOracle.updateOracle(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setWhitelistStatus(\\n    address collateral,\\n    uint8 whitelistStatus,\\n    bytes memory whitelistData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external restricted {\\n    LibSetters.updatePayees(_payees, _shares, _skipRelease);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external restricted {\\n    LibSetters.updateSlippageTolerance(collateral, slippageTolerance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {\\n    LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setSwapRouter(address swapRouter) external restricted {\\n    LibSetters.setSwapRouter(swapRouter);\\n  }\\n}\\n\",\"keccak256\":\"0x7c64a27bfb326989b6fdc21b3982ef5ce95aa2a576a4edc6d8334a8820f3b8fb\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport { LibSurplus } from \\\"./LibSurplus.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { LibDiamond } from \\\"./LibDiamond.sol\\\";\\nimport { LibWhitelist } from \\\"./LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibSetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibSetters.sol\\nlibrary LibSetters {\\n  using SafeCast for uint256;\\n\\n  event CollateralAdded(address indexed collateral);\\n  event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);\\n  event CollateralRevoked(address indexed collateral);\\n  event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);\\n  event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);\\n  event OracleSet(address indexed collateral, bytes oracleConfig);\\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n  event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);\\n  event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);\\n  event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);\\n  event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);\\n  event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);\\n  event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);\\n  event PayeeAdded(address indexed payee, uint256 shares);\\n  event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);\\n  event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);\\n  event SwapRouterUpdated(address indexed swapRouter);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GOVERNOR ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `setAccessManager`\\n  function setAccessManager(IAccessManager _newAccessManager) internal {\\n    if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();\\n    DiamondStorage storage ds = s.diamondStorage();\\n    address previousAccessManager = address(ds.accessManager);\\n    ds.accessManager = _newAccessManager;\\n    emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));\\n  }\\n\\n  /// @notice Internal version of `setCollateralManager`\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    internal\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    if (managerData.config.length != 0) {\\n      // The first subCollateral given should be the actual collateral asset\\n      if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();\\n      // Sanity check on the manager data that is passed\\n      LibManager.parseManagerConfig(managerData.config);\\n      collatInfo.isManaged = 1;\\n    } else {\\n      collatInfo.isManaged = 0;\\n    }\\n    collatInfo.managerData = managerData;\\n    emit CollateralManagerSet(collateral, managerData);\\n  }\\n\\n  /// @notice Internal version of `toggleTrusted`\\n  function toggleTrusted(address sender, TrustedType t) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 trustedStatus;\\n    if (t == TrustedType.Updater) {\\n      trustedStatus = 1 - ts.isTrusted[sender];\\n      ts.isTrusted[sender] = trustedStatus;\\n    } else {\\n      trustedStatus = 1 - ts.isSellerTrusted[sender];\\n      ts.isSellerTrusted[sender] = trustedStatus;\\n    }\\n    emit TrustedToggled(sender, trustedStatus == 1, t);\\n  }\\n\\n  /// @notice Internal version of `addCollateral`\\n  function addCollateral(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals != 0) revert AlreadyAdded();\\n    collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());\\n    ts.collateralList.push(collateral);\\n    emit CollateralAdded(collateral);\\n  }\\n\\n  /// @notice Internal version of `adjustStablecoins`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();\\n    if (increase) {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables + normalizedAmount;\\n      if (uint256(collatInfo.normalizedStables) * uint256(ts.normalizer) / BASE_27 > collatInfo.stablecoinCap) {\\n        revert AboveCap();\\n      }\\n    } else {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables - normalizedAmount;\\n    }\\n    emit ReservesAdjusted(collateral, amount, increase);\\n  }\\n\\n  /// @notice Internal version of `revokeCollateral`\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (collatInfo.normalizedStables > 0) revert CollateralBacked();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    delete ts.collaterals[collateral];\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 length = collateralListMem.length;\\n    for (uint256 i; i < length - 1; ++i) {\\n      if (collateralListMem[i] == collateral) {\\n        ts.collateralList[i] = collateralListMem[length - 1];\\n        break;\\n      }\\n    }\\n    ts.collateralList.pop();\\n    emit CollateralRevoked(collateral);\\n  }\\n\\n  /// @notice Internal version of `setOracle`\\n  function setOracle(address collateral, bytes memory oracleConfig) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    (,,,, bytes memory hyperparameters) =\\n      abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    if (userDeviation > burnRatioDeviation) revert InvalidParams();\\n    // Checks oracle validity\\n    LibOracle.readMint(oracleConfig);\\n    collatInfo.oracleConfig = oracleConfig;\\n    emit OracleSet(collateral, oracleConfig);\\n  }\\n\\n  /// @notice Internal version of `setWhitelistStatus`\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {\\n    if (whitelistStatus > 1) revert InvalidWhitelistStatus();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (whitelistStatus == 1) {\\n      // Sanity check\\n      LibWhitelist.checkWhitelist(whitelistData, address(this));\\n      collatInfo.whitelistData = whitelistData;\\n    } else {\\n      // If whitelist is revoked, clear the whitelist data\\n      collatInfo.whitelistData = \\\"\\\";\\n    }\\n    collatInfo.onlyWhitelisted = whitelistStatus;\\n    emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GUARDIAN ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `pause` \\u2014 sets the action's live flag to `0`\\n  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance\\n  /// call cannot pass silently\\n  function pause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 0);\\n  }\\n\\n  /// @notice Internal version of `unpause` \\u2014 sets the action's live flag to `1`\\n  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance\\n  /// call cannot pass silently\\n  function unpause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 1);\\n  }\\n\\n  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`\\n  /// to unpause. Reverts on no-op transitions.\\n  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;\\n      if (currentIsLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      if (action == ActionType.Mint) {\\n        collatInfo.isMintLive = targetIsLive;\\n      } else {\\n        collatInfo.isBurnLive = targetIsLive;\\n      }\\n    } else {\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      if (ts.isRedemptionLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      ts.isRedemptionLive = targetIsLive;\\n    }\\n    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);\\n  }\\n\\n  /// @notice Internal version of `setFees`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);\\n    if (mint) {\\n      collatInfo.xFeeMint = xFee;\\n      collatInfo.yFeeMint = yFee;\\n    } else {\\n      collatInfo.xFeeBurn = xFee;\\n      collatInfo.yFeeBurn = yFee;\\n    }\\n    emit FeesSet(collateral, xFee, yFee, mint);\\n  }\\n\\n  /// @notice Internal version of `setRedemptionCurveParams`\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    LibSetters.checkFees(xFee, yFee, ActionType.Redeem);\\n    ts.xRedemptionCurve = xFee;\\n    ts.yRedemptionCurve = yFee;\\n    emit RedemptionCurveParamsSet(xFee, yFee);\\n  }\\n\\n  /// @notice Internal version of `toggleWhitelist`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];\\n    ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;\\n    emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);\\n  }\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a collateral\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    collatInfo.stablecoinCap = stablecoinCap;\\n    emit StablecoinCapSet(collateral, stablecoinCap);\\n  }\\n\\n  /// @notice Internal version of `updatePayees`\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) internal {\\n    if (_payees.length == 0 || _payees.length > MAX_PAYEES) revert InvalidLengths();\\n    if (_payees.length != _shares.length) revert ArrayLengthMismatch();\\n    /// @dev Distribute the fees before updating the fee receivers.\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!_skipRelease) {\\n      uint256 income = ts.tokenP.balanceOf(address(this));\\n      if (income > 0 && ts.payees.length > 0) {\\n        LibSurplus.release(income, ts.payees);\\n      }\\n    }\\n\\n    // Zero out stale shares for old payees\\n    uint256 i = 0;\\n    for (; i < ts.payees.length; ++i) {\\n      ts.shares[ts.payees[i]] = 0;\\n    }\\n    delete ts.payees;\\n    uint256 _totalShares = 0;\\n    i = 0;\\n    for (; i < _payees.length; ++i) {\\n      for (uint256 j = 0; j < i; ++j) {\\n        if (_payees[j] == _payees[i]) revert AlreadyAdded();\\n      }\\n      _totalShares += _addPayee(_payees[i], _shares[i]);\\n    }\\n    ts.totalShares = _totalShares;\\n  }\\n\\n  /// @notice Internal version of `updateSlippageTolerance`\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) internal {\\n    if (slippageTolerance > BASE_9) revert InvalidRate();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.slippageTolerance[collateral] = slippageTolerance;\\n    emit SlippageToleranceUpdated(collateral, slippageTolerance);\\n  }\\n\\n  /// @notice Internal version of `setSwapRouter`\\n  function setSwapRouter(address swapRouter) internal {\\n    if (swapRouter == address(0)) revert ZeroAddress();\\n    s.transmuterStorage().swapRouter = swapRouter;\\n    emit SwapRouterUpdated(swapRouter);\\n  }\\n\\n  /// @notice Internal version of `updateSurplusBufferRatio`\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {\\n    if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.surplusBufferRatio = _surplusBufferRatio;\\n    emit SurplusBufferRatioUpdated(_surplusBufferRatio);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions\\n  function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {\\n    uint256 n = xFee.length;\\n    if (n != yFee.length || n == 0) revert InvalidParams();\\n    if (\\n      // Mint inflexion points should be in [0,BASE_9[\\n      // We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9\\n      // Hence we consider BASE_12 as the max value (100% fees) for yFeeMint\\n      // Burn inflexion points should be in [0,BASE_9] but fees should be constant in\\n      // the first segment [BASE_9, x_{n-1}[\\n      // Redemption inflexion points should be in [0,BASE_9]\\n      (action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))\\n        || (action == ActionType.Burn\\n          && (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1]))))\\n        || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))\\n    ) {\\n      revert InvalidParams();\\n    }\\n\\n    for (uint256 i; i < n - 1; ++i) {\\n      if (\\n        // xFee strictly increasing and yFee increasing for mints\\n        // xFee strictly decreasing and yFee increasing for burns\\n        // xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions\\n        (action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))\\n      ) revert InvalidParams();\\n    }\\n\\n    // If a mint or burn fee is negative, we need to check that accounts atomically minting\\n    // (from any collateral) and then burning cannot get more than their initial value\\n    if (yFee[0] < 0) {\\n      if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 length = collateralListMem.length;\\n      if (action == ActionType.Mint) {\\n        // This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;\\n          if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n      if (action == ActionType.Burn) {\\n        // This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;\\n          if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n    }\\n  }\\n\\n  /// @notice Add a new fee receiver.\\n  /// @param _payee The address of the fee receiver.\\n  /// @param _shares The number of shares assigned to the fee receiver.\\n  function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {\\n    if (_shares == 0) revert ZeroAmount();\\n    // The Parallelizer holds the income being distributed, so a share allocated to itself is handed\\n    // back to `release` as fresh income on the next call. `address(0)` stays valid: `LibSurplus`\\n    // treats it as the sentinel for burning that share.\\n    if (_payee == address(this)) revert InvalidPayee();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n\\n    ts.payees.push(_payee);\\n    ts.shares[_payee] = _shares;\\n    emit PayeeAdded(_payee, _shares);\\n    return _shares;\\n  }\\n}\\n\",\"keccak256\":\"0x45ed1863aec8d20f3659d2b0ea657b629b5c33b71f895ae6775ea72156203197\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
   },
   "userdoc": {
+    "events": {
+      "OracleTargetUpdated(address,uint256,uint256)": {
+        "notice": "Emitted when a MAX target price is ratcheted up by `updateOracle`"
+      }
+    },
     "kind": "user",
     "methods": {
       "addCollateral(address)": {
@@ -836,6 +906,9 @@
       "setOracle(address,bytes)": {
         "notice": "Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations"
       },
+      "setSwapRouter(address)": {
+        "notice": "Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to"
+      },
       "setWhitelistStatus(address,uint8,bytes)": {
         "notice": "Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist"
       },
@@ -859,13 +932,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0xfb091a00aadea9cf54b65b9fcb744a358b7370de3abab4adf9d529ee54a25db7",
-    "nonce": "0xc3",
+    "hash": "0x40f801f383cda7f46bb2b357fbcaf586b3f926bd522ba6e90a7f2a9838440461",
+    "nonce": "0xdf",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
-    "blockHash": "0x57d3cc6ba3b3be9dc3190557e8e8bc06fba4b527a1c4d2099bba74d908dc0f05",
-    "blockNumber": "0x56e29d9",
-    "transactionIndex": "0x6"
+    "blockHash": "0xa194fda89069cf1af4ee9ace3d0842b46e13ad0969140c8688cf31e2ef7bf8b9",
+    "blockNumber": "0x5c76692",
+    "transactionIndex": "0xd"
   }
 }
\ No newline at end of file

From c8bbe99d533e3f27c9a728c5e35417abda365dbc Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Thu, 15 Oct 2026 14:14:06 +0400
Subject: [PATCH 30/38] chore(deployments): record the base facets upgrade and
 GenericRebalancer

SettersGovernor, Getters, Redeemer and RewardHandler are redeployed, the other
facets already had the current bytecode. The GenericRebalancer is deployed
behind the team CooperAccessManager.
---
 deployments/base/GenericRebalancer_USDp.json | 1228 ++++++++++++++++++
 deployments/base/Getters.json                |   44 +-
 deployments/base/Redeemer.json               |   69 +-
 deployments/base/RewardHandler.json          |   33 +-
 deployments/base/SettersGovernor.json        |   95 +-
 5 files changed, 1405 insertions(+), 64 deletions(-)
 create mode 100644 deployments/base/GenericRebalancer_USDp.json

diff --git a/deployments/base/GenericRebalancer_USDp.json b/deployments/base/GenericRebalancer_USDp.json
new file mode 100644
index 0000000..9eaf281
--- /dev/null
+++ b/deployments/base/GenericRebalancer_USDp.json
@@ -0,0 +1,1228 @@
+{
+  "address": "0x10ca75cf3a2198d5571148949ef4531b2d57de7d",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "initialTokenTransferAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "initialSwapRouter",
+          "type": "address"
+        },
+        {
+          "internalType": "contract ITokenP",
+          "name": "definitivetokenP",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IParallelizer",
+          "name": "definitiveParallelizer",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "initialAuthority",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC3156FlashLender",
+          "name": "definitiveFlashloan",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "authority",
+          "type": "address"
+        }
+      ],
+      "name": "AccessManagedInvalidAuthority",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        },
+        {
+          "internalType": "uint32",
+          "name": "delay",
+          "type": "uint32"
+        }
+      ],
+      "name": "AccessManagedRequiredDelay",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        }
+      ],
+      "name": "AccessManagedUnauthorized",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "InvalidParam",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "NotTrusted",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "NotTrustedOrGuardian",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        }
+      ],
+      "name": "SafeERC20FailedOperation",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "SwapError",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "ZeroAmount",
+      "type": "error"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "AllowanceReset",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "authority",
+          "type": "address"
+        }
+      ],
+      "name": "AuthorityUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "Recovered",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newSwapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "SwapRouterUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newTokenTransferAddress",
+          "type": "address"
+        }
+      ],
+      "name": "TokenTransferAddressUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "trusted",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "bool",
+          "name": "status",
+          "type": "bool"
+        }
+      ],
+      "name": "TrustedToggled",
+      "type": "event"
+    },
+    {
+      "inputs": [],
+      "name": "CALLBACK_SUCCESS",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "addBudget",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "authority",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "budget",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        }
+      ],
+      "name": "computeRebalanceAmount",
+      "outputs": [
+        {
+          "internalType": "uint8",
+          "name": "increase",
+          "type": "uint8"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "flashloan",
+      "outputs": [
+        {
+          "internalType": "contract IERC3156FlashLender",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "scale",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "extraData",
+          "type": "bytes"
+        }
+      ],
+      "name": "harvest",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isConsumingScheduledOp",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "",
+          "type": "bytes4"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "isTrusted",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "initiator",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "fee",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        }
+      ],
+      "name": "onFlashLoan",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "parallelizer",
+      "outputs": [
+        {
+          "internalType": "contract IParallelizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountToRecover",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "recoverERC20",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "removeBudget",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "resetAllowance",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newAuthority",
+          "type": "address"
+        }
+      ],
+      "name": "setAuthority",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "newMaxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "name": "setMaxSlippage",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newSwapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "setSwapRouter",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        }
+      ],
+      "name": "setTargetExposure",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newTokenTransferAddress",
+          "type": "address"
+        }
+      ],
+      "name": "setTokenTransferAddress",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "asset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "minExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "overrideExposures",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "name": "setYieldBearingAssetData",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "swapRouter",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "trusted",
+          "type": "address"
+        }
+      ],
+      "name": "toggleTrusted",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "tokenP",
+      "outputs": [
+        {
+          "internalType": "contract ITokenP",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "tokenTransferAddress",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        }
+      ],
+      "name": "updateLimitExposuresYieldAsset",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "yieldBearingData",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "asset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "minExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "overrideExposures",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "contractName": "GenericRebalancer",
+  "sourceName": "contracts/helpers/GenericRebalancer.sol",
+  "bytecode": "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",
+  "deployedBytecode": "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",
+  "linkReferences": {},
+  "deployedLinkReferences": {},
+  "immutableReferences": {
+    "10252": [
+      {
+        "length": 32,
+        "start": 629
+      },
+      {
+        "length": 32,
+        "start": 1913
+      },
+      {
+        "length": 32,
+        "start": 2055
+      },
+      {
+        "length": 32,
+        "start": 2191
+      },
+      {
+        "length": 32,
+        "start": 4217
+      },
+      {
+        "length": 32,
+        "start": 5920
+      },
+      {
+        "length": 32,
+        "start": 6053
+      },
+      {
+        "length": 32,
+        "start": 6348
+      },
+      {
+        "length": 32,
+        "start": 6493
+      },
+      {
+        "length": 32,
+        "start": 7129
+      },
+      {
+        "length": 32,
+        "start": 7419
+      }
+    ],
+    "10256": [
+      {
+        "length": 32,
+        "start": 470
+      },
+      {
+        "length": 32,
+        "start": 1497
+      },
+      {
+        "length": 32,
+        "start": 1849
+      },
+      {
+        "length": 32,
+        "start": 2137
+      },
+      {
+        "length": 32,
+        "start": 3715
+      },
+      {
+        "length": 32,
+        "start": 6001
+      },
+      {
+        "length": 32,
+        "start": 8074
+      }
+    ],
+    "11053": [
+      {
+        "length": 32,
+        "start": 538
+      },
+      {
+        "length": 32,
+        "start": 1553
+      },
+      {
+        "length": 32,
+        "start": 8026
+      }
+    ]
+  },
+  "inputSourceName": "project/contracts/helpers/GenericRebalancer.sol",
+  "devdoc": {
+    "author": "Cooper Labs",
+    "custom:contact": "security@cooperlabs.xyz",
+    "details": "Generic contract for trusted callers to adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract, substantially modified: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
+    "errors": {
+      "SafeERC20FailedOperation(address)": [
+        {
+          "details": "An operation with an ERC-20 token failed."
+        }
+      ]
+    },
+    "events": {
+      "AuthorityUpdated(address)": {
+        "details": "Authority that manages this contract was updated."
+      }
+    },
+    "kind": "dev",
+    "methods": {
+      "addBudget(uint256,address)": {
+        "params": {
+          "amount": "amount of tokenP to add to the budget",
+          "receiver": "address of the receiver"
+        }
+      },
+      "authority()": {
+        "details": "Returns the current authority."
+      },
+      "computeRebalanceAmount(address)": {
+        "params": {
+          "yieldBearingAsset": "address of the yield bearing asset"
+        },
+        "returns": {
+          "amount": "amount to be rebalanced",
+          "increase": "whether the exposure should be increased"
+        }
+      },
+      "harvest(address,uint256,bytes)": {
+        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippageRestricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the collateral oracle, neither of which can be safely exposed to arbitrary callers"
+      },
+      "isConsumingScheduledOp()": {
+        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
+      },
+      "onFlashLoan(address,address,uint256,uint256,bytes)": {
+        "details": "A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any shortfall between the principal and the tokenP the rebalance minted back",
+        "params": {
+          "amount": "The amount of tokens lent.",
+          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
+          "fee": "The additional amount of tokens to repay.",
+          "initiator": "The initiator of the loan.",
+          "token": "The loan currency."
+        },
+        "returns": {
+          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
+        }
+      },
+      "recoverERC20(address,uint256,address)": {
+        "params": {
+          "amountToRecover": "amount to recover",
+          "to": "address to send the recovered tokens",
+          "tokenAddress": "address of the token to recover"
+        }
+      },
+      "removeBudget(uint256,address)": {
+        "params": {
+          "amount": "amount of tokenP to remove from the budget",
+          "receiver": "address of the receiver"
+        }
+      },
+      "resetAllowance(address,address)": {
+        "details": "Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing asset's configuration revokes the approvals it created, but this covers a spender that became untrusted for any other reason.",
+        "params": {
+          "spender": "address losing the allowance",
+          "token": "address of the token"
+        }
+      },
+      "setAuthority(address)": {
+        "details": "Transfers control to a new authority. The caller must be the current authority."
+      },
+      "setMaxSlippage(address,uint64)": {
+        "params": {
+          "newMaxSlippage": "new max allowed slippage"
+        }
+      },
+      "setSwapRouter(address)": {
+        "params": {
+          "newSwapRouter": "address of the swap router"
+        }
+      },
+      "setTargetExposure(address,uint64)": {
+        "params": {
+          "targetExposure": "target exposure to the yield bearing asset used",
+          "yieldBearingAsset": "address of the yield bearing asset"
+        }
+      },
+      "setTokenTransferAddress(address)": {
+        "params": {
+          "newTokenTransferAddress": "address of the token transfer contract"
+        }
+      },
+      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": {
+        "params": {
+          "asset": "address of the asset",
+          "maxExposure": "maximum exposure within the Parallelizer to the asset",
+          "minExposure": "minimum exposure within the Parallelizer to the asset",
+          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
+          "targetExposure": "target exposure to the yieldBearingAsset asset used",
+          "yieldBearingAsset": "address of the yieldBearingAsset"
+        }
+      },
+      "toggleTrusted(address)": {
+        "params": {
+          "trusted": "address to toggle the trusted status"
+        }
+      },
+      "updateLimitExposuresYieldAsset(address)": {
+        "params": {
+          "yieldBearingAsset": "address of the yield bearing asset"
+        }
+      }
+    },
+    "title": "GenericRebalancer",
+    "version": 1
+  },
+  "evm": {
+    "gasEstimates": {
+      "creation": {
+        "codeDepositCost": "2436200",
+        "executionCost": "infinite",
+        "totalCost": "infinite"
+      },
+      "external": {
+        "CALLBACK_SUCCESS()": "240",
+        "addBudget(uint256,address)": "infinite",
+        "authority()": "2407",
+        "budget(address)": "2554",
+        "computeRebalanceAmount(address)": "infinite",
+        "flashloan()": "infinite",
+        "harvest(address,uint256,bytes)": "infinite",
+        "isConsumingScheduledOp()": "2442",
+        "isTrusted(address)": "2612",
+        "onFlashLoan(address,address,uint256,uint256,bytes)": "infinite",
+        "parallelizer()": "infinite",
+        "recoverERC20(address,uint256,address)": "infinite",
+        "removeBudget(uint256,address)": "infinite",
+        "resetAllowance(address,address)": "infinite",
+        "setAuthority(address)": "30486",
+        "setMaxSlippage(address,uint64)": "infinite",
+        "setSwapRouter(address)": "infinite",
+        "setTargetExposure(address,uint64)": "infinite",
+        "setTokenTransferAddress(address)": "infinite",
+        "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": "infinite",
+        "swapRouter()": "2392",
+        "toggleTrusted(address)": "infinite",
+        "tokenP()": "infinite",
+        "tokenTransferAddress()": "2415",
+        "updateLimitExposuresYieldAsset(address)": "infinite",
+        "yieldBearingData(address)": "5001"
+      },
+      "internal": {
+        "_adjustYieldExposure(uint256,uint8,address,address,uint256,enum SwapType,bytes memory)": "infinite",
+        "_recoverResidualInput(address,uint256)": "infinite",
+        "_swapToTokenOut(uint256,address,address,uint256,enum SwapType,bytes memory)": "infinite",
+        "_swapToTokenOutSwap(address,address,uint256,bytes memory)": "infinite",
+        "_swapToTokenOutVault(uint256,address,address,uint256)": "infinite"
+      }
+    }
+  },
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"AllowanceReset\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"resetAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newMaxSlippage\",\"type\":\"uint64\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxSlippage\",\"type\":\"uint64\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxSlippage\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for trusted callers to adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract, substantially modified: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippageRestricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the collateral oracle, neither of which can be safely exposed to arbitrary callers\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any shortfall between the principal and the tokenP the rebalance minted back\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"resetAllowance(address,address)\":{\"details\":\"Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing asset's configuration revokes the approvals it created, but this covers a spender that became untrusted for any other reason.\",\"params\":{\"spender\":\"address losing the allowance\",\"token\":\"address of the token\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint64)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericRebalancer\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"resetAllowance(address,address)\":{\"notice\":\"Set an allowance this contract granted back to zero\"},\"setMaxSlippage(address,uint64)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/helpers/GenericRebalancer.sol\":\"GenericRebalancer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0x1121e070554cffc6d536f658332a1a3d65fb2ea5573cd774f4ecbd02a2fcf4b7\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x4e4b982b56b50290dd1dcaa2fef1178b1574dfc7c0f0a8ef9cb68a207d72582e\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity >=0.5.0;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x218d708e7d8df417db24a497727eefb7772e61c7cde3886fc42bbcb6aafa6947\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/helpers/BaseRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IRebalancer.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer, bounded below 1e9 so uint64 leaves the\\n  // struct packed in two slots\\n  uint64 maxSlippage;\\n}\\n\\n/// @title BaseRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a rebalancer that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract, substantially modified:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseRebalancer is IRebalancer, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n  event AllowanceReset(address indexed token, address indexed spender);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /**\\n   * @notice Set an allowance this contract granted back to zero\\n   * @param token address of the token\\n   * @param spender address losing the allowance\\n   * @dev Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing\\n   * asset's configuration revokes the approvals it created, but this covers a spender that became\\n   * untrusted for any other reason.\\n   */\\n  function resetAllowance(address token, address spender) external restricted {\\n    IERC20(token).forceApprove(spender, 0);\\n    emit AllowanceReset(token, spender);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    address previousAsset = yieldBearingInfo.asset;\\n    // Allowances are granted without expiry, so the outgoing asset would keep the yield bearing\\n    // vault authorised over any of it later held here\\n    if (previousAsset != address(0) && previousAsset != asset) {\\n      IERC20(previousAsset).forceApprove(yieldBearingAsset, 0);\\n      emit AllowanceReset(previousAsset, yieldBearingAsset);\\n      _revokeAssetAllowances(yieldBearingAsset, previousAsset);\\n    }\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /// @notice Lets a rebalancer revoke the allowances it granted over an asset being rotated out\\n  function _revokeAssetAllowances(address yieldBearingAsset, address previousAsset) internal virtual { }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingData[yieldBearingAsset].maxSlippage = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x5d05479be1ac7d1dc738cb8fc2e539c82e88a2191dee278cc74fd647eed17ebc\",\"license\":\"GPL-3.0\"},\"project/contracts/helpers/GenericRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseRebalancer, YieldBearingParams } from \\\"./BaseRebalancer.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for trusted callers to adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract, substantially modified:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseRebalancer(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  /// @dev Restricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the\\n  /// collateral oracle, neither of which can be safely exposed to arbitrary callers\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual onlyTrusted {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  /// @dev A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any\\n  /// shortfall between the principal and the tokenP the rebalance minted back\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this)) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 tokenInBalanceBefore = IERC20(tokenIn).balanceOf(address(this));\\n\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n    // The principal is spent, what the lender will pull back is the principal plus its fee\\n    amount += fee;\\n\\n    // Swap to tokenOut\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n\\n    amountStableOut += _recoverResidualInput(tokenIn, tokenInBalanceBefore);\\n\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    } else if (amountStableOut > amount) {\\n      budget[sender] += amountStableOut - amount;\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  /**\\n   * @dev Returns any input the route did not consume to the Parallelizer\\n   * @param tokenIn address of the token offered to the route\\n   * @param balanceBefore balance of `tokenIn` held before the operation\\n   * @return the tokenP obtained from the remainder, zero when the route consumed everything\\n   *\\n   * Router calldata is built off chain while the input is sized on chain, so a route can consume\\n   * less than was offered. Returning the remainder keeps it inside the Parallelizer's accounting\\n   * instead of stranding it here, and it settles with the rest of the operation.\\n   */\\n  function _recoverResidualInput(address tokenIn, uint256 balanceBefore) internal returns (uint256) {\\n    uint256 balanceAfter = IERC20(tokenIn).balanceOf(address(this));\\n    if (balanceAfter <= balanceBefore) return 0;\\n    uint256 residual = balanceAfter - balanceBefore;\\n    _adjustAllowance(tokenIn, address(parallelizer), residual);\\n    return parallelizer.swapExactInput(residual, 0, tokenIn, address(tokenP), address(this), block.timestamp);\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n    // A route that consumed less than offered would otherwise leave the difference approved\\n    IERC20(tokenIn).forceApprove(tokenTransferAddress, 0);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0xe10b65b2a75ead0d938a2282cf478e94ea425adb38a03ca077fa0422ec2d322c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  function getSwapRouter() external view returns (address);\\n\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x27a333b02ba124b5964a63bddeb301328197bddbe98538903cd41a8b40900d12\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\nimport { ISurplus } from \\\"./ISurplus.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuter` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuter.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper,\\n  ISurplus\\n{ }\\n\",\"keccak256\":\"0x3d43efebf663185429a411300477c3a62bf5e025fb286cf812cd0b589fb8bd5a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IRebalancer {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0a30a492e29ebe67db0f4cac7bfb142d04556a61282e71733d13c11daeba08b1\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was\\n  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since\\n  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`\\n  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity\\n  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x3362bd4532915b6e2b26b2fdc967a89ea66de5ea5f669d7a621ee69d75c02273\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a call to the configured swap router\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to the swap router\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xb3604f35c5bb44791020588e00774299a6a4adae17d62d1e53cd8be86da6b709\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n\\n  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain\\n  /// specific and must be set on every deployment before rewards can be sold\\n  function setSwapRouter(address swapRouter) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xe62d2880420afb053498b01f1def17d4c8e2c6c9b48cc5a71d013150a5ca8db4\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISurplus.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISurplus {\\n  /// @dev This function will swap the surplus of a collateral for the stable asset link to the protocol.\\n  /// @param collateral The collateral address to process the surplus of.\\n  /// @param maxCollateralAmount The maximum amount of collateral to process. If 0, processes the full surplus.\\n  /// @return collateralSurplus The surplus of the collateral actually processed.\\n  /// @return stableSurplus The surplus amount in stable calculated from the collateral surplus.\\n  /// @return issuedAmount The amount of newly issued stablecoins from the collateral swapped\\n  function processSurplus(\\n    address collateral,\\n    uint256 maxCollateralAmount\\n  )\\n    external\\n    returns (uint256 collateralSurplus, uint256 stableSurplus, uint256 issuedAmount);\\n\\n  /// @notice Releases the income to the payees\\n  /// @return payees The addresses of the payees\\n  /// @return amounts The amounts released to the payees\\n  function release() external returns (address[] memory payees, uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x0129ea80a666d553ddd13c02f56a72cc96a6ac4e45578f0f523def2732ce450f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactInput`, but using a single EIP-3009 authorization for `tokenIn`.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeSwapExactInputNonce(...)`,\\n  /// which binds the full swap intent. `authData.nonce` carries the caller-chosen `userSalt`; the\\n  /// facet recomputes the derived nonce from the call arguments before forwarding it to the\\n  /// token, so any tampering with `to`/slippage/deadline invalidates the signature.\\n  /// @param authData ABI-encoded `AuthorizationParams` with `nonce = userSalt`\\n  function swapExactInputWithAuthorization(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata authData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactOutput`, but using a single EIP-3009 authorization for `tokenIn`.\\n  /// @dev The authorization must be signed for `amountInMax`; the excess is refunded to the\\n  /// authorizer. Derived-nonce scheme as in `swapExactInputWithAuthorization`, using\\n  /// `LibAuthorization.computeSwapExactOutputNonce(...)`.\\n  /// @param authData ABI-encoded `AuthorizationParams` with `nonce = userSalt`\\n  function swapExactOutputWithAuthorization(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata authData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0xbf7e08cff6dd51c222f86976d3526307098b80100c81978a55566043924cfc06\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"},\"project/libs/helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"}},\"version\":1}",
+  "storageLayout": {
+    "storage": [
+      {
+        "astId": 29857,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "_authority",
+        "offset": 0,
+        "slot": "0",
+        "type": "t_address"
+      },
+      {
+        "astId": 29859,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "_consumingSchedule",
+        "offset": 20,
+        "slot": "0",
+        "type": "t_bool"
+      },
+      {
+        "astId": 10262,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "yieldBearingData",
+        "offset": 0,
+        "slot": "1",
+        "type": "t_mapping(t_address,t_struct(YieldBearingParams)10202_storage)"
+      },
+      {
+        "astId": 10267,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "isTrusted",
+        "offset": 0,
+        "slot": "2",
+        "type": "t_mapping(t_address,t_bool)"
+      },
+      {
+        "astId": 30616,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "swapRouter",
+        "offset": 0,
+        "slot": "3",
+        "type": "t_address"
+      },
+      {
+        "astId": 30619,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "tokenTransferAddress",
+        "offset": 0,
+        "slot": "4",
+        "type": "t_address"
+      },
+      {
+        "astId": 11058,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "budget",
+        "offset": 0,
+        "slot": "5",
+        "type": "t_mapping(t_address,t_uint256)"
+      }
+    ],
+    "types": {
+      "t_address": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      },
+      "t_bool": {
+        "encoding": "inplace",
+        "label": "bool",
+        "numberOfBytes": "1"
+      },
+      "t_mapping(t_address,t_bool)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => bool)",
+        "numberOfBytes": "32",
+        "value": "t_bool"
+      },
+      "t_mapping(t_address,t_struct(YieldBearingParams)10202_storage)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => struct YieldBearingParams)",
+        "numberOfBytes": "32",
+        "value": "t_struct(YieldBearingParams)10202_storage"
+      },
+      "t_mapping(t_address,t_uint256)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => uint256)",
+        "numberOfBytes": "32",
+        "value": "t_uint256"
+      },
+      "t_struct(YieldBearingParams)10202_storage": {
+        "encoding": "inplace",
+        "label": "struct YieldBearingParams",
+        "members": [
+          {
+            "astId": 10191,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "asset",
+            "offset": 0,
+            "slot": "0",
+            "type": "t_address"
+          },
+          {
+            "astId": 10193,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "targetExposure",
+            "offset": 20,
+            "slot": "0",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10195,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "maxExposure",
+            "offset": 0,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10197,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "minExposure",
+            "offset": 8,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10199,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "overrideExposures",
+            "offset": 16,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10201,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "maxSlippage",
+            "offset": 24,
+            "slot": "1",
+            "type": "t_uint64"
+          }
+        ],
+        "numberOfBytes": "64"
+      },
+      "t_uint256": {
+        "encoding": "inplace",
+        "label": "uint256",
+        "numberOfBytes": "32"
+      },
+      "t_uint64": {
+        "encoding": "inplace",
+        "label": "uint64",
+        "numberOfBytes": "8"
+      }
+    }
+  },
+  "userdoc": {
+    "events": {
+      "SwapRouterUpdated(address)": {
+        "notice": "Event emitted when the swap router is updated"
+      },
+      "TokenTransferAddressUpdated(address)": {
+        "notice": "Event emitted when the token proxy is updated"
+      }
+    },
+    "kind": "user",
+    "methods": {
+      "addBudget(uint256,address)": {
+        "notice": "Add budget to be spent by the receiver during the flashloan"
+      },
+      "budget(address)": {
+        "notice": "Budget of tokenP available for each users"
+      },
+      "computeRebalanceAmount(address)": {
+        "notice": "Compute the amount needed to rebalance the Parallelizer"
+      },
+      "flashloan()": {
+        "notice": "Parallel stablecoin flashloan contract"
+      },
+      "harvest(address,uint256,bytes)": {
+        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
+      },
+      "isTrusted(address)": {
+        "notice": "trusted addresses that can update target exposure and do others non critical operations"
+      },
+      "parallelizer()": {
+        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
+      },
+      "recoverERC20(address,uint256,address)": {
+        "notice": "Recover ERC20 tokens"
+      },
+      "removeBudget(uint256,address)": {
+        "notice": "Remove budget from the owner and send it to the receiver"
+      },
+      "resetAllowance(address,address)": {
+        "notice": "Set an allowance this contract granted back to zero"
+      },
+      "setMaxSlippage(address,uint64)": {
+        "notice": "Set the max allowed slippage"
+      },
+      "setSwapRouter(address)": {
+        "notice": "Set the swap router"
+      },
+      "setTargetExposure(address,uint64)": {
+        "notice": "Set the target exposure of a yield bearing asset"
+      },
+      "setTokenTransferAddress(address)": {
+        "notice": "Set the token transfer address"
+      },
+      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": {
+        "notice": "Set the yieldBearingAsset data"
+      },
+      "swapRouter()": {
+        "notice": "address of the router/aggregator"
+      },
+      "toggleTrusted(address)": {
+        "notice": "Toggle the trusted status of an address"
+      },
+      "tokenP()": {
+        "notice": "TokenP handled by the `parallelizer` of interest"
+      },
+      "tokenTransferAddress()": {
+        "notice": "address to approve to transfer tokens to"
+      },
+      "updateLimitExposuresYieldAsset(address)": {
+        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
+      },
+      "yieldBearingData(address)": {
+        "notice": "Data associated to a yield bearing asset"
+      }
+    },
+    "version": 1
+  },
+  "argsData": "0x00000000000000000000000019ceead7105607cd444f5ad10dd51356436095a100000000000000000000000019ceead7105607cd444f5ad10dd51356436095a100000000000000000000000076a9a0062ec6712b99b4f63bd2b4270185759dd5000000000000000000000000c3bef21ea7deb5c34cf33e918c8e28972c8048ed0000000000000000000000000f5543b12781242e192b4f85240280e168481b5a00000000000000000000000008417cdb7f52a5021bb4eb6e0deaf3f295c3f182",
+  "transaction": {
+    "hash": "0xea9b52019858bb2d90968a15d2a89388664f0f892ba0e29134a2e00d9ed16c8f",
+    "nonce": "0xcf",
+    "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
+  },
+  "receipt": {
+    "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
+    "blockNumber": "0x3232450",
+    "transactionIndex": "0x30"
+  }
+}
\ No newline at end of file
diff --git a/deployments/base/Getters.json b/deployments/base/Getters.json
index b346388..e8e7c45 100644
--- a/deployments/base/Getters.json
+++ b/deployments/base/Getters.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x2b822194bea84cbf5b52956eb3435e58d20abd1f",
+  "address": "0xa5b6c0c6afbfb5c8808ec3ad3db9098a6b82433a",
   "abi": [
     {
       "inputs": [],
@@ -549,6 +549,19 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "getSwapRouter",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [],
       "name": "getTotalIssued",
@@ -752,8 +765,8 @@
   ],
   "contractName": "Getters",
   "sourceName": "contracts/parallelizer/facets/Getters.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -804,7 +817,7 @@
       "getSlippageTolerance(address)": {
         "details": "Maximum slippage tolerance is 1e9 (100%)"
       },
-      "getSurplusBufferRatio()": {
+      "getSwapRouter()": {
         "details": "Expressed in base 1e9, and always >= 1e9"
       },
       "isConsumingScheduledOp()": {
@@ -823,9 +836,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "3346200",
-        "executionCost": "3721",
-        "totalCost": "3349921"
+        "codeDepositCost": "3358000",
+        "executionCost": "3737",
+        "totalCost": "3361737"
       },
       "external": {
         "accessManager()": "2418",
@@ -847,7 +860,8 @@
         "getShares(address)": "2561",
         "getSlippageTolerance(address)": "2564",
         "getStablecoinCap(address)": "infinite",
-        "getSurplusBufferRatio()": "2356",
+        "getSurplusBufferRatio()": "2334",
+        "getSwapRouter()": "2420",
         "getTotalIssued()": "infinite",
         "getTotalShares()": "2369",
         "isConsumingScheduledOp()": "infinite",
@@ -862,7 +876,7 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SurplusBufferRatioNotSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroSurplusAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"accessManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralBurnFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralDecimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isManaged\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isMintLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isBurnLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"onlyWhitelisted\",\"type\":\"uint8\"},{\"internalType\":\"uint216\",\"name\":\"normalizedStables\",\"type\":\"uint216\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinCap\",\"type\":\"uint256\"}],\"internalType\":\"struct Collateral\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralList\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralMintFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"collatRatio\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralSurplus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"collateralSurplus\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableSurplus\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralWhitelistData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getIssuedByCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stablecoinsFromCollateral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastReleasedAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getManagerData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracle\",\"outputs\":[{\"internalType\":\"enum OracleReadType\",\"name\":\"oracleType\",\"type\":\"uint8\"},{\"internalType\":\"enum OracleReadType\",\"name\":\"targetType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"oracleData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"targetData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hyperparameters\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracleValues\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"mint\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"burn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ratio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minRatio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"redemption\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPayees\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRedemptionFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xRedemptionCurve\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yRedemptionCurve\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"getShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getSlippageTolerance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getStablecoinCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSurplusBufferRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"enum ActionType\",\"name\":\"action\",\"type\":\"uint8\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrustedSeller\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"isValidSelector\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"isWhitelistedCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enum WhitelistType\",\"name\":\"whitelistType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForType\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"There may be duplicates in the info provided by the getters defined hereThis contract is an authorized fork of Angle's `Getters` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}]},\"kind\":\"dev\",\"methods\":{\"getCollateralRatio()\":{\"details\":\"This function may revert and overflow if the collateral ratio is too big due to a too small amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function become economically impossible\"},\"getCollateralSurplus(address)\":{\"params\":{\"collateral\":\"The collateral address to compute the surplus of.\"},\"returns\":{\"collateralSurplus\":\"The collateral surplus amount.\",\"stableSurplus\":\"The surplus in stable amount.\"}},\"getOracle(address)\":{\"returns\":{\"oracleData\":\"Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\",\"oracleType\":\"Type of oracle (Chainlink, external smart contract, ...)\",\"targetData\":\"Extra data needed to read the target price of the asset\",\"targetType\":\"Type passed to read the value of the target price\"}},\"getOracleValues(address)\":{\"details\":\"This function is not optimized for gas consumption as for instance the `burn` value for collateral is computed twice: once in `readBurn` and once in `getBurnOracle`\",\"returns\":{\"burn\":\"Oracle value that will be used for `collateral` for a burn transaction. This value is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\",\"minRatio\":\"Minimum ratio across all collateral assets between a collateral burn price and its target price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn transactions.\",\"mint\":\"Oracle value to be used for a mint transaction with `collateral`\",\"ratio\":\"Ratio, in base `10**18` between the oracle value of the `collateral` and its target price. This value is 10**18 if the oracle is greater than the collateral price\",\"redemption\":\"Oracle value that would be used to price `collateral` when computing the collateral ratio during a redemption\"}},\"getSlippageTolerance(address)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)\"},\"getSurplusBufferRatio()\":{\"details\":\"Expressed in base 1e9, and always >= 1e9\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"isWhitelistedForCollateral(address,address)\":{\"details\":\"This function is non view as it may consult external non view functions from whitelist providers\"},\"isWhitelistedForType(uint8,address)\":{\"details\":\"Note that ultimately whitelisting may depend as well on external providers\"}},\"title\":\"Getters\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"accessManager()\":{\"notice\":\"Returns the address of the `accessManager` contract\"},\"getCollateralBurnFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn for `collateral`\"},\"getCollateralDecimals(address)\":{\"notice\":\"Returns the decimals of a given `collateral`\"},\"getCollateralInfo(address)\":{\"notice\":\"Returns all the info in storage associated to a `collateral`\"},\"getCollateralList()\":{\"notice\":\"Returns the list of collateral assets supported by the system\"},\"getCollateralMintFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint with `collateral`\"},\"getCollateralRatio()\":{\"notice\":\"Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount of stablecoins issued\"},\"getCollateralSurplus(address)\":{\"notice\":\"Computes the surplus of a collateral.\"},\"getCollateralWhitelistData(address)\":{\"notice\":\"Gets the data needed to deal with whitelists for `collateral`\"},\"getIssuedByCollateral(address)\":{\"notice\":\"Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued through Parallelizer\"},\"getLastReleasedAt()\":{\"notice\":\"Returns the last time the income was released to the payees\"},\"getManagerData(address)\":{\"notice\":\"Returns if a collateral is \\\"managed\\\" and the associated manager configuration\"},\"getOracle(address)\":{\"notice\":\"Returns the data used to compute oracle values for `collateral`\"},\"getOracleValues(address)\":{\"notice\":\"Returns the oracle values associated to `collateral`\"},\"getPayees()\":{\"notice\":\"Returns the payees and their shares\"},\"getRedemptionFees()\":{\"notice\":\"Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral ratio when users come to redeem\"},\"getShares(address)\":{\"notice\":\"Returns the shares of a payee\"},\"getSlippageTolerance(address)\":{\"notice\":\"Returns the slippage tolerance for a `collateral` for the surplus\"},\"getStablecoinCap(address)\":{\"notice\":\"Returns the stablecoin cap for `collateral`\"},\"getSurplusBufferRatio()\":{\"notice\":\"Returns the minimum collateral ratio that must hold after surplus processing\"},\"getTotalIssued()\":{\"notice\":\"Returns the total amount of stablecoins issued through Parallelizer\"},\"getTotalShares()\":{\"notice\":\"Returns the total shares of the payees\"},\"isPaused(address,uint8)\":{\"notice\":\"Returns if the associated functionality is paused or not\"},\"isTrusted(address)\":{\"notice\":\"Returns if `sender` is trusted to update normalizers\"},\"isTrustedSeller(address)\":{\"notice\":\"Returns if `sender` is trusted to update sell rewards\"},\"isValidSelector(bytes4)\":{\"notice\":\"Checks whether a given `selector` is actually a valid selector corresponding to a function in one of the facets of the proxy\"},\"isWhitelistedCollateral(address)\":{\"notice\":\"Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForCollateral(address,address)\":{\"notice\":\"Checks whether `sender` can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForType(uint8,address)\":{\"notice\":\"Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\"},\"tokenP()\":{\"notice\":\"Stablecoin minted by parallelizer\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Getters.sol\":\"Getters\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x04f12ddeb53bb3bba9aaf9a93c62a84076cca496642d4d87556b15120b60e07b\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Getters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IGetters } from \\\"contracts/interfaces/IGetters.sol\\\";\\n\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibSurplus } from \\\"../libraries/LibSurplus.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Getters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev There may be duplicates in the info provided by the getters defined here\\n/// @dev This contract is an authorized fork of Angle's `Getters` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\\ncontract Getters is IGetters {\\n  /// @inheritdoc IGetters\\n  function isValidSelector(bytes4 selector) external view returns (bool) {\\n    return s.diamondStorage().selectorInfo[selector].facetAddress != address(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function tokenP() external view returns (ITokenP) {\\n    return s.transmuterStorage().tokenP;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralList() external view returns (address[] memory) {\\n    return s.transmuterStorage().collateralList;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory) {\\n    return s.transmuterStorage().collaterals[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralDecimals(address collateral) external view returns (uint8) {\\n    return s.transmuterStorage().collaterals[collateral].decimals;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralMintFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeMint, int64[] memory yFeeMint)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeMint, collatInfo.yFeeMint);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralBurnFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeBurn, int64[] memory yFeeBurn)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeBurn, collatInfo.yFeeBurn);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getRedemptionFees()\\n    external\\n    view\\n    returns (uint64[] memory xRedemptionCurve, int64[] memory yRedemptionCurve)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (ts.xRedemptionCurve, ts.yRedemptionCurve);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function may revert and overflow if the collateral ratio is too big due to a too small\\n  /// amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non\\n  /// negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function\\n  /// become economically impossible\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n\\n    (collatRatio, stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    return (\\n      (uint256(ts.collaterals[collateral].normalizedStables) * _normalizer) / BASE_27,\\n      (uint256(ts.normalizedStables) * _normalizer) / BASE_27\\n    );\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalIssued() external view returns (uint256) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (uint256(ts.normalizedStables) * uint256(ts.normalizer)) / BASE_27;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getManagerData(address collateral) external view returns (bool, IERC20[] memory, bytes memory) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      return (true, collatInfo.managerData.subCollaterals, collatInfo.managerData.config);\\n    }\\n    return (false, new IERC20[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is not optimized for gas consumption as for instance the `burn` value for collateral\\n  /// is computed twice: once in `readBurn` and once in `getBurnOracle`\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption)\\n  {\\n    bytes memory oracleConfig = s.transmuterStorage().collaterals[collateral].oracleConfig;\\n    (burn, ratio) = LibOracle.readBurn(oracleConfig);\\n    (minRatio,) = LibOracle.getBurnOracle(collateral, oracleConfig);\\n    return (LibOracle.readMint(oracleConfig), burn, ratio, minRatio, LibOracle.readRedemption(oracleConfig));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    )\\n  {\\n    return LibOracle.getOracle(collateral);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isPaused(address collateral, ActionType action) external view returns (bool) {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      if (action == ActionType.Mint) {\\n        return collatInfo.isMintLive == 0;\\n      } else {\\n        return collatInfo.isBurnLive == 0;\\n      }\\n    } else {\\n      return s.transmuterStorage().isRedemptionLive == 0;\\n    }\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrusted(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrustedSeller(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isSellerTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool) {\\n    return s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is non view as it may consult external non view functions from whitelist providers\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.onlyWhitelisted == 0 || LibWhitelist.checkWhitelist(collatInfo.whitelistData, sender));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedCollateral(address collateral) external view returns (bool) {\\n    return s.transmuterStorage().collaterals[collateral].onlyWhitelisted == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory) {\\n    return s.transmuterStorage().collaterals[collateral].whitelistData;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getStablecoinCap(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().collaterals[collateral].stablecoinCap;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function accessManager() external view returns (address) {\\n    return address(s.diamondStorage().accessManager);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isConsumingScheduledOp() external view returns (bytes4) {\\n    return s.transmuterStorage().consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getPayees() external view returns (address[] memory, uint256[] memory) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory payees = new address[](ts.payees.length);\\n    uint256[] memory shares = new uint256[](ts.payees.length);\\n    for (uint256 i = 0; i < ts.payees.length; i++) {\\n      payees[i] = ts.payees[i];\\n      shares[i] = ts.shares[ts.payees[i]];\\n    }\\n    return (payees, shares);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalShares() external view returns (uint256) {\\n    return s.transmuterStorage().totalShares;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getShares(address payee) external view returns (uint256) {\\n    return s.transmuterStorage().shares[payee];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSlippageTolerance(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().slippageTolerance[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSurplusBufferRatio() external view returns (uint64) {\\n    return s.transmuterStorage().surplusBufferRatio;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getLastReleasedAt() external view returns (uint256) {\\n    return s.transmuterStorage().lastReleasedAt;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    return LibSurplus._computeCollateralSurplus(collateral);\\n  }\\n}\\n\",\"keccak256\":\"0xd53f1dc85e3e3b30205017bf00b54c9b511963034d382ecc647e65ad854b314e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SurplusBufferRatioNotSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroSurplusAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"accessManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralBurnFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralDecimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isManaged\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isMintLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isBurnLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"onlyWhitelisted\",\"type\":\"uint8\"},{\"internalType\":\"uint216\",\"name\":\"normalizedStables\",\"type\":\"uint216\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinCap\",\"type\":\"uint256\"}],\"internalType\":\"struct Collateral\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralList\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralMintFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"collatRatio\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralSurplus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"collateralSurplus\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableSurplus\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralWhitelistData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getIssuedByCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stablecoinsFromCollateral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastReleasedAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getManagerData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracle\",\"outputs\":[{\"internalType\":\"enum OracleReadType\",\"name\":\"oracleType\",\"type\":\"uint8\"},{\"internalType\":\"enum OracleReadType\",\"name\":\"targetType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"oracleData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"targetData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hyperparameters\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracleValues\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"mint\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"burn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ratio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minRatio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"redemption\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPayees\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRedemptionFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xRedemptionCurve\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yRedemptionCurve\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"getShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getSlippageTolerance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getStablecoinCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSurplusBufferRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSwapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"enum ActionType\",\"name\":\"action\",\"type\":\"uint8\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrustedSeller\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"isValidSelector\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"isWhitelistedCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enum WhitelistType\",\"name\":\"whitelistType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForType\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"There may be duplicates in the info provided by the getters defined hereThis contract is an authorized fork of Angle's `Getters` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}]},\"kind\":\"dev\",\"methods\":{\"getCollateralRatio()\":{\"details\":\"This function may revert and overflow if the collateral ratio is too big due to a too small amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function become economically impossible\"},\"getCollateralSurplus(address)\":{\"params\":{\"collateral\":\"The collateral address to compute the surplus of.\"},\"returns\":{\"collateralSurplus\":\"The collateral surplus amount.\",\"stableSurplus\":\"The surplus in stable amount.\"}},\"getOracle(address)\":{\"returns\":{\"oracleData\":\"Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\",\"oracleType\":\"Type of oracle (Chainlink, external smart contract, ...)\",\"targetData\":\"Extra data needed to read the target price of the asset\",\"targetType\":\"Type passed to read the value of the target price\"}},\"getOracleValues(address)\":{\"details\":\"This function is not optimized for gas consumption as for instance the `burn` value for collateral is computed twice: once in `readBurn` and once in `getBurnOracle`\",\"returns\":{\"burn\":\"Oracle value that will be used for `collateral` for a burn transaction. This value is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\",\"minRatio\":\"Minimum ratio across all collateral assets between a collateral burn price and its target price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn transactions.\",\"mint\":\"Oracle value to be used for a mint transaction with `collateral`\",\"ratio\":\"Ratio, in base `10**18` between the oracle value of the `collateral` and its target price. This value is 10**18 if the oracle is greater than the collateral price\",\"redemption\":\"Oracle value that would be used to price `collateral` when computing the collateral ratio during a redemption\"}},\"getSlippageTolerance(address)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)\"},\"getSwapRouter()\":{\"details\":\"Expressed in base 1e9, and always >= 1e9\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"isWhitelistedForCollateral(address,address)\":{\"details\":\"This function is non view as it may consult external non view functions from whitelist providers\"},\"isWhitelistedForType(uint8,address)\":{\"details\":\"Note that ultimately whitelisting may depend as well on external providers\"}},\"title\":\"Getters\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"accessManager()\":{\"notice\":\"Returns the address of the `accessManager` contract\"},\"getCollateralBurnFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn for `collateral`\"},\"getCollateralDecimals(address)\":{\"notice\":\"Returns the decimals of a given `collateral`\"},\"getCollateralInfo(address)\":{\"notice\":\"Returns all the info in storage associated to a `collateral`\"},\"getCollateralList()\":{\"notice\":\"Returns the list of collateral assets supported by the system\"},\"getCollateralMintFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint with `collateral`\"},\"getCollateralRatio()\":{\"notice\":\"Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount of stablecoins issued\"},\"getCollateralSurplus(address)\":{\"notice\":\"Computes the surplus of a collateral.\"},\"getCollateralWhitelistData(address)\":{\"notice\":\"Gets the data needed to deal with whitelists for `collateral`\"},\"getIssuedByCollateral(address)\":{\"notice\":\"Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued through Parallelizer\"},\"getLastReleasedAt()\":{\"notice\":\"Returns the last time the income was released to the payees\"},\"getManagerData(address)\":{\"notice\":\"Returns if a collateral is \\\"managed\\\" and the associated manager configuration\"},\"getOracle(address)\":{\"notice\":\"Returns the data used to compute oracle values for `collateral`\"},\"getOracleValues(address)\":{\"notice\":\"Returns the oracle values associated to `collateral`\"},\"getPayees()\":{\"notice\":\"Returns the payees and their shares\"},\"getRedemptionFees()\":{\"notice\":\"Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral ratio when users come to redeem\"},\"getShares(address)\":{\"notice\":\"Returns the shares of a payee\"},\"getSlippageTolerance(address)\":{\"notice\":\"Returns the slippage tolerance for a `collateral` for the surplus\"},\"getStablecoinCap(address)\":{\"notice\":\"Returns the stablecoin cap for `collateral`\"},\"getSwapRouter()\":{\"notice\":\"Returns the minimum collateral ratio that must hold after surplus processingReturns the aggregator or DEX the `RewardHandler` forwards its swap payload to\"},\"getTotalIssued()\":{\"notice\":\"Returns the total amount of stablecoins issued through Parallelizer\"},\"getTotalShares()\":{\"notice\":\"Returns the total shares of the payees\"},\"isPaused(address,uint8)\":{\"notice\":\"Returns if the associated functionality is paused or not\"},\"isTrusted(address)\":{\"notice\":\"Returns if `sender` is trusted to update normalizers\"},\"isTrustedSeller(address)\":{\"notice\":\"Returns if `sender` is trusted to update sell rewards\"},\"isValidSelector(bytes4)\":{\"notice\":\"Checks whether a given `selector` is actually a valid selector corresponding to a function in one of the facets of the proxy\"},\"isWhitelistedCollateral(address)\":{\"notice\":\"Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForCollateral(address,address)\":{\"notice\":\"Checks whether `sender` can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForType(uint8,address)\":{\"notice\":\"Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\"},\"tokenP()\":{\"notice\":\"Stablecoin minted by parallelizer\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Getters.sol\":\"Getters\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  function getSwapRouter() external view returns (address);\\n\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x27a333b02ba124b5964a63bddeb301328197bddbe98538903cd41a8b40900d12\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Getters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IGetters } from \\\"contracts/interfaces/IGetters.sol\\\";\\n\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibSurplus } from \\\"../libraries/LibSurplus.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Getters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev There may be duplicates in the info provided by the getters defined here\\n/// @dev This contract is an authorized fork of Angle's `Getters` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\\ncontract Getters is IGetters {\\n  /// @inheritdoc IGetters\\n  function isValidSelector(bytes4 selector) external view returns (bool) {\\n    return s.diamondStorage().selectorInfo[selector].facetAddress != address(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function tokenP() external view returns (ITokenP) {\\n    return s.transmuterStorage().tokenP;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralList() external view returns (address[] memory) {\\n    return s.transmuterStorage().collateralList;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory) {\\n    return s.transmuterStorage().collaterals[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralDecimals(address collateral) external view returns (uint8) {\\n    return s.transmuterStorage().collaterals[collateral].decimals;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralMintFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeMint, int64[] memory yFeeMint)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeMint, collatInfo.yFeeMint);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralBurnFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeBurn, int64[] memory yFeeBurn)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeBurn, collatInfo.yFeeBurn);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getRedemptionFees()\\n    external\\n    view\\n    returns (uint64[] memory xRedemptionCurve, int64[] memory yRedemptionCurve)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (ts.xRedemptionCurve, ts.yRedemptionCurve);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function may revert and overflow if the collateral ratio is too big due to a too small\\n  /// amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non\\n  /// negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function\\n  /// become economically impossible\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n\\n    (collatRatio, stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    return (\\n      (uint256(ts.collaterals[collateral].normalizedStables) * _normalizer) / BASE_27,\\n      (uint256(ts.normalizedStables) * _normalizer) / BASE_27\\n    );\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalIssued() external view returns (uint256) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (uint256(ts.normalizedStables) * uint256(ts.normalizer)) / BASE_27;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getManagerData(address collateral) external view returns (bool, IERC20[] memory, bytes memory) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      return (true, collatInfo.managerData.subCollaterals, collatInfo.managerData.config);\\n    }\\n    return (false, new IERC20[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is not optimized for gas consumption as for instance the `burn` value for collateral\\n  /// is computed twice: once in `readBurn` and once in `getBurnOracle`\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption)\\n  {\\n    bytes memory oracleConfig = s.transmuterStorage().collaterals[collateral].oracleConfig;\\n    (burn, ratio) = LibOracle.readBurn(oracleConfig);\\n    (minRatio,) = LibOracle.getBurnOracle(collateral, oracleConfig);\\n    return (LibOracle.readMint(oracleConfig), burn, ratio, minRatio, LibOracle.readRedemption(oracleConfig));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    )\\n  {\\n    return LibOracle.getOracle(collateral);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isPaused(address collateral, ActionType action) external view returns (bool) {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      if (action == ActionType.Mint) {\\n        return collatInfo.isMintLive == 0;\\n      } else {\\n        return collatInfo.isBurnLive == 0;\\n      }\\n    } else {\\n      return s.transmuterStorage().isRedemptionLive == 0;\\n    }\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrusted(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrustedSeller(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isSellerTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool) {\\n    return s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is non view as it may consult external non view functions from whitelist providers\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.onlyWhitelisted == 0 || LibWhitelist.checkWhitelist(collatInfo.whitelistData, sender));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedCollateral(address collateral) external view returns (bool) {\\n    return s.transmuterStorage().collaterals[collateral].onlyWhitelisted == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory) {\\n    return s.transmuterStorage().collaterals[collateral].whitelistData;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getStablecoinCap(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().collaterals[collateral].stablecoinCap;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function accessManager() external view returns (address) {\\n    return address(s.diamondStorage().accessManager);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isConsumingScheduledOp() external view returns (bytes4) {\\n    return s.transmuterStorage().consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getPayees() external view returns (address[] memory, uint256[] memory) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory payees = new address[](ts.payees.length);\\n    uint256[] memory shares = new uint256[](ts.payees.length);\\n    for (uint256 i = 0; i < ts.payees.length; i++) {\\n      payees[i] = ts.payees[i];\\n      shares[i] = ts.shares[ts.payees[i]];\\n    }\\n    return (payees, shares);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalShares() external view returns (uint256) {\\n    return s.transmuterStorage().totalShares;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getShares(address payee) external view returns (uint256) {\\n    return s.transmuterStorage().shares[payee];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSlippageTolerance(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().slippageTolerance[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSwapRouter() external view returns (address) {\\n    return s.transmuterStorage().swapRouter;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSurplusBufferRatio() external view returns (uint64) {\\n    return s.transmuterStorage().surplusBufferRatio;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getLastReleasedAt() external view returns (uint256) {\\n    return s.transmuterStorage().lastReleasedAt;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    return LibSurplus._computeCollateralSurplus(collateral);\\n  }\\n}\\n\",\"keccak256\":\"0x7698420203383c245b91740b40652708e240877ec9d006d211556c7ffe0406e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -927,8 +941,8 @@
       "getStablecoinCap(address)": {
         "notice": "Returns the stablecoin cap for `collateral`"
       },
-      "getSurplusBufferRatio()": {
-        "notice": "Returns the minimum collateral ratio that must hold after surplus processing"
+      "getSwapRouter()": {
+        "notice": "Returns the minimum collateral ratio that must hold after surplus processingReturns the aggregator or DEX the `RewardHandler` forwards its swap payload to"
       },
       "getTotalIssued()": {
         "notice": "Returns the total amount of stablecoins issued through Parallelizer"
@@ -965,13 +979,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0xb143a60af6483f74ce57f394644cdaef5542302a6b975b151eb7696a3ea612f9",
-    "nonce": "0xb0",
+    "hash": "0xa73cf8bcdb6cfa1b5138eb6c73e260f5661fc58181f1942c6438603006db5584",
+    "nonce": "0xcc",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
     "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-    "blockNumber": "0x2eb0650",
-    "transactionIndex": "0x21"
+    "blockNumber": "0x31e6d75",
+    "transactionIndex": "0x6a"
   }
 }
\ No newline at end of file
diff --git a/deployments/base/Redeemer.json b/deployments/base/Redeemer.json
index a6e12dc..12ac433 100644
--- a/deployments/base/Redeemer.json
+++ b/deployments/base/Redeemer.json
@@ -1,5 +1,5 @@
 {
-  "address": "0xa2ebf74746eed7d586b3b9696511a553210d1b09",
+  "address": "0xd5ef1d8c08ed5b9fbe9b1ff806defd9ca985d8b9",
   "abi": [
     {
       "inputs": [],
@@ -78,6 +78,11 @@
       "name": "TooSmallAmountOut",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "UnexpectedRedemptionTokens",
+      "type": "error"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -179,6 +184,11 @@
           "internalType": "uint256[]",
           "name": "minAmountOuts",
           "type": "uint256[]"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
         }
       ],
       "name": "redeem",
@@ -224,6 +234,11 @@
           "name": "forfeitTokens",
           "type": "address[]"
         },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
+        },
         {
           "internalType": "bytes",
           "name": "authData",
@@ -272,6 +287,11 @@
           "internalType": "address[]",
           "name": "forfeitTokens",
           "type": "address[]"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
         }
       ],
       "name": "redeemWithForfeit",
@@ -317,8 +337,8 @@
   ],
   "contractName": "Redeemer",
   "sourceName": "contracts/parallelizer/facets/Redeemer.sol",
-  "bytecode": "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",
-  "deployedBytecode": "0x608060405234801561000f575f5ffd5b5060043610610064575f3560e01c8063815822c11161004d578063815822c1146100a5578063d703a0cd146100b8578063fd7daaf8146100cb575f5ffd5b80632e7639bc1461006857806356018dc014610092575b5f5ffd5b61007b610076366004612c7a565b6100ec565b604051610089929190612d76565b60405180910390f35b61007b6100a0366004612dc1565b61011a565b61007b6100b3366004612eae565b61013a565b61007b6100c6366004612f0d565b610190565b6100de6100d9366004612f31565b6101a7565b604051908152602001610089565b60608061010b878787878760405180602001604052805f815250610235565b915091505b9550959350505050565b60608061012b888888888888610235565b91509150965096945050505050565b606080610183868686865f60405190808252806020026020018201604052801561016e578160200160208202803683370190505b5060405180602001604052805f815250610235565b9150915094509492505050565b60608061019c836104e2565b509094909350915050565b5f6101b3335f36610793565b1580156101eb5750335f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7b6020526040902054155b15610222576040517fc22a648e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61022c83836108cc565b90505b92915050565b5f516020613a075f395f51905f528054606091829160ff600160a81b909104166001190161028f576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff60a81b191675020000000000000000000000000000000000000000001781555f516020613a075f395f51905f525474010000000000000000000000000000000000000000900460ff165f03610314576040517f9e87fac800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8642111561034e576040517fecdd1c2900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103a56040518061010001604052805f81526020015f6001600160a01b031681526020015f6001600160a01b0316815260200160608152602001606081526020016060815260200160608152602001606081525090565b8981526001600160a01b038916604082015260c0810187905260e081018690526103ce8a6104e2565b60a0840152608083018190526060830191909152875190511461041d576040517f1df89e8b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6104278a5f6108cc565b506104368a8a8a8a8a8a610c16565b6001600160a01b0316602082015261044d81610d14565b80604001516001600160a01b031681602001516001600160a01b03167f3998bcf315dae4953d294b3ca6e1d0074c249adc136b50d1ff99b04753c73e7f835f0151846060015185608001518660e001516040516104ad9493929190612f5f565b60405180910390a3806060015181608001519350935050805460ff60a81b1916600160a81b1790559097909650945050505050565b60608060605f5f6104f1611134565b91985096509450909250905080861061051c5760405162839e0f60e81b815260040160405180910390fd5b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c798054604080516020808402820181019092528281525f516020613a075f395f51905f52935f9391929091908301828280156105b757602002820191905f5260205f20905f905b825461010083900a900460070b81526020600f83018190049384019360010360089093019290920291018084116105835790505b505050505090505f633b9aca008567ffffffffffffffff16101561066b575f8360030180548060200260200160405190810160405280929190818152602001828054801561065557602002820191905f5260205f20905f905b82829054906101000a900467ffffffffffffffff1667ffffffffffffffff16815260200190600801906020826007010492830192600103820291508084116106105790505b5050505050905061066786828561177b565b9150505b5f5b875181101561078657633b9aca008667ffffffffffffffff1610156106e35761069a633b9aca0086612fb1565b8267ffffffffffffffff168983815181106106b7576106b7612fc8565b60200260200101518c6106ca9190612fb1565b6106d49190612fb1565b6106de9190612ff0565b610761565b6106f767ffffffffffffffff871686612fb1565b83600185516107069190613003565b8151811061071657610716612fc8565b602002602001015167ffffffffffffffff1689838151811061073a5761073a612fc8565b60200260200101518c61074d9190612fb1565b6107579190612fb1565b6107619190612ff0565b88828151811061077357610773612fc8565b602090810291909101015260010161066d565b5050505050509193909250565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d545f906001600160a01b031681806107e38388306107d56004868b8d613016565b6107de9161303d565b61191b565b91509150816108bd5763ffffffff8116156108b2575f516020613a075f395f51905f52805460ff60b01b19167601000000000000000000000000000000000000000000001781556040517f94c7d7ee0000000000000000000000000000000000000000000000000000000081526001600160a01b038516906394c7d7ee90610873908b908b908b906004016130a3565b5f604051808303815f87803b15801561088a575f5ffd5b505af115801561089c573d5f5f3e3d5ffd5b5050825460ff60b01b1916909255506108bd9050565b5f93505050506108c5565b600193505050505b9392505050565b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c76545f905f516020613a075f395f51905f52906001600160801b03600160801b820481169116841561094a578061092f6b033b2e3c9fd0803ce800000088612fb1565b6109399190612ff0565b61094390836130e1565b9350610978565b806109616b033b2e3c9fd0803ce800000088612fb1565b61096b9190612ff0565b6109759083613003565b93505b670de0b6b3a76400008411158061099e57506ec097ce7bc90715b34b9f10000000008410155b15610b7c575f836002018054806020026020016040519081016040528092919081815260200182805480156109fa57602002820191905f5260205f20905b81546001600160a01b031681526001909101906020018083116109dc575b505050505090505f815190505f5f5b82811015610b2f575f610a9c6b033b2e3c9fd0803ce80000008a8a6005015f898781518110610a3a57610a3a612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f2054610a8d91906501000000000090047affffffffffffffffffffffffffffffffffffffffffffffffffffff16612fb1565b610a979190612ff0565b6119f3565b9050610aa881846130f4565b9250806001600160801b0316886005015f878581518110610acb57610acb612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f2080547affffffffffffffffffffffffffffffffffffffffffffffffffffff92909216650100000000000264ffffffffff90921691909117905550600101610a09565b506001860180547fffffffffffffffffffffffffffffffff00000000000000000000000000000000166001600160801b0392909216919091179055506b033b2e3c9fd0803ce80000009450505b610b85846119f3565b6001840180546001600160801b03928316600160801b02921691909117905584158015610bbd575060018301546001600160801b0316155b15610bda5760405162839e0f60e81b815260040160405180910390fd5b6040518481527fb4fde7403c001c7cdeafc0c3bb46e972111b7efac4e832398cbf9fabe1694ed99060200160405180910390a150505092915050565b5f516020613a075f395f51905f525481515f916001600160a01b03169015610ca957610c46888888888888611a2f565b6040516315a38ec760e11b8152600481018a90523060248201529092506001600160a01b03821690632b471d8e906044015f604051808303815f87803b158015610c8e575f5ffd5b505af1158015610ca0573d5f5f3e3d5ffd5b50505050610d09565b6040516315a38ec760e11b815260048101899052336024820181905292506001600160a01b03821690632b471d8e906044015f604051808303815f87803b158015610cf2575f5ffd5b505af1158015610d04573d5f5f3e3d5ffd5b505050505b509695505050505050565b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c778054604080516020808402820181019092528281525f516020613a075f395f51905f52935f939192909190830182828015610d9757602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610d79575b505050505090505f5f84608001515190505f5b8181101561112c578560c001518181518110610dc857610dc8612fc8565b602002602001015186608001518281518110610de657610de6612fc8565b60200260200101511015610e26576040517fa1aabbe100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f86608001518281518110610e3d57610e3d612fc8565b6020026020010151118015610e7b57505f610e7987606001518381518110610e6757610e67612fc8565b60200260200101518860e00151611b4b565b125b156110e8575f856005015f868681518110610e9857610e98612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f208054909150640100000000900460ff1615801590610f6d5750610f6b816006018054610ee590613113565b80601f0160208091040260200160405190810160405280929190818152602001828054610f1190613113565b8015610f5c5780601f10610f3357610100808354040283529160200191610f5c565b820191905f5260205f20905b815481529060010190602001808311610f3f57829003601f168201915b50505050508860400151611ba7565b155b15610fa4576040517f584a793800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff161561108a5761108587606001518381518110610fc757610fc7612fc8565b6020026020010151886040015189608001518581518110610fea57610fea612fc8565b602002602001015184600701600101805461100490613113565b80601f016020809104026020016040519081016040528092919081815260200182805461103090613113565b801561107b5780601f106110525761010080835404028352916020019161107b565b820191905f5260205f20905b81548152906001019060200180831161105e57829003601f168201915b5050505050611d18565b6110e6565b6110e68760400151886080015184815181106110a8576110a8612fc8565b6020026020010151896060015185815181106110c6576110c6612fc8565b60200260200101516001600160a01b0316611dd99092919063ffffffff16565b505b8060018760a00151858151811061110157611101612fc8565b60200260200101516111139190613003565b11611124576111218361314b565b92505b600101610daa565b505050505050565b5f8060608080835f516020613a075f395f51905f5290505f5f826002018054806020026020016040519081016040528092919081815260200182805480156111a357602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311611185575b505050505090505f815190505f8167ffffffffffffffff8111156111c9576111c9612b1b565b6040519080825280602002602001820160405280156111f2578160200160208202803683370190505b5095505f5b828110156112c457856005015f85838151811061121657611216612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f9081205460ff1690036112545761124d8261314b565b915061129e565b856005015f85838151811061126b5761126b612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f206007015461129b90836130e1565b91505b818782815181106112b1576112b1612fc8565b60209081029190910101526001016111f7565b508067ffffffffffffffff8111156112de576112de612b1b565b604051908082528060200260200182016040528015611307578160200160208202803683370190505b5096508067ffffffffffffffff81111561132357611323612b1b565b60405190808252806020026020018201604052801561134c578160200160208202803683370190505b5097505f5f5b83811015611707575f876005015f87848151811061137257611372612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f908120805490925060ff161561151057606061143b8360070160010180546113ba90613113565b80601f01602080910402602001604051908101604052809291908181526020018280546113e690613113565b80156114315780601f1061140857610100808354040283529160200191611431565b820191905f5260205f20905b81548152906001019060200180831161141457829003601f168201915b5050505050611e5e565b81519093509091505f5b818110156114fc576007850180548290811061146357611463612fc8565b5f918252602090912001546001600160a01b03168f611482838a6130e1565b8151811061149257611492612fc8565b60200260200101906001600160a01b031690816001600160a01b0316815250508281815181106114c4576114c4612fc8565b60200260200101518e82896114d991906130e1565b815181106114e9576114e9612fc8565b6020908102919091010152600101611445565b5061150781876130e1565b9550505061161e565b86838151811061152257611522612fc8565b60209081029190910101516040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa158015611589573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906115ad9190613163565b90508683815181106115c1576115c1612fc8565b60200260200101518c85815181106115db576115db612fc8565b6001600160a01b0390921660209283029190910190910152808b856115ff8161314b565b96508151811061161157611611612fc8565b6020026020010181815250505b5f6116b283600501805461163190613113565b80601f016020809104026020016040519081016040528092919081815260200182805461165d90613113565b80156116a85780601f1061167f576101008083540402835291602001916116a8565b820191905f5260205f20905b81548152906001019060200180831161168b57829003601f168201915b5050505050611f0d565b8354909150670de0b6b3a7640000906116d99084906301000000900460ff1660125f611fce565b6116e39083612fb1565b6116ed9190612ff0565b6116f7908a6130e1565b9850505050806001019050611352565b505060018086015461173b916001600160801b0380831692600160801b900416906b033b2e3c9fd0803ce800000090612049565b985088156117635761175c61175785633b9aca008c6001612049565b61208b565b995061176f565b67ffffffffffffffff99505b50505050509091929394565b5f5f61178b6001856001886120c1565b9050801580156117c75750835f815181106117a8576117a8612fc8565b602002602001015167ffffffffffffffff168567ffffffffffffffff16105b156117ee57825f815181106117de576117de612fc8565b60200260200101519150506108c5565b600184516117fc9190613003565b81036118215782600185516118119190613003565b815181106117de576117de612fc8565b83818151811061183357611833612fc8565b60200260200101518482600161184991906130e1565b8151811061185957611859612fc8565b602002602001015161186b919061317a565b84828151811061187d5761187d612fc8565b602002602001015186611890919061317a565b8483815181106118a2576118a2612fc8565b6020026020010151858460016118b891906130e1565b815181106118c8576118c8612fc8565b60200260200101516118da919061319a565b6118e491906131c9565b6118ee91906131e8565b83828151811061190057611900612fc8565b60200260200101516119129190613225565b95945050505050565b6040516001600160a01b038085166024830152831660448201527fffffffff00000000000000000000000000000000000000000000000000000000821660648201525f908190819060840160408051601f19818403018152918152602080830180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fb7009613000000000000000000000000000000000000000000000000000000001781525f808052918290528351939450919290918a5afa156119e9575f516020805191945081901c150291505b5094509492505050565b5f6001600160801b03821115611a2b576040516306dfcc6560e41b815260806004820152602481018390526044015b60405180910390fd5b5090565b5f5f82806020019051810190611a4591906132a1565b905087816020015114611a84576040517f1115766700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f611a9b825f01518a8a8a8a8a8860800151612256565b5f516020613a075f395f51905f525483516020850151604080870151606088015160a089015192517f88b7ab630000000000000000000000000000000000000000000000000000000081529697506001600160a01b03909516956388b7ab6395611b10959430949093928a9190600401613348565b5f604051808303815f87803b158015611b27575f5ffd5b505af1158015611b39573d5f5f3e3d5ffd5b505092519a9950505050505050505050565b80515f90815b81811015611b9c57838181518110611b6b57611b6b612fc8565b60200260200101516001600160a01b0316856001600160a01b031603611b9457915061022f9050565b600101611b51565b505f19949350505050565b5f5f5f84806020019051810190611bbe91906133c8565b915091505f611bd75f516020613a075f395f51905f5290565b6008015f848015611bea57611bea613416565b8015611bf857611bf8613416565b81526020019081526020015f205f866001600160a01b03166001600160a01b031681526020019081526020015f20541115611c385760019250505061022f565b805115611d0e575f828015611c4f57611c4f613416565b03611d0e575f81806020019051810190611c69919061342a565b90506001600160a01b03811615611d0c576040517f65e4ad9e0000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b0386811660248301528216906365e4ad9e906044016020604051808303815f875af1158015611cde573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611d029190613445565b935050505061022f565b505b505f949350505050565b5f5f611d2383612339565b90925090505f828015611d3857611d38613416565b0361112c5780806020019051810190611d51919061342a565b6040517f8bfb07c90000000000000000000000000000000000000000000000000000000081526001600160a01b0388811660048301528781166024830152604482018790529190911690638bfb07c9906064015f604051808303815f87803b158015611dbb575f5ffd5b505af1158015611dcd573d5f5f3e3d5ffd5b50505050505050505050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052611e5990849061235a565b505050565b60605f5f5f611e6c85612339565b90925090505f828015611e8157611e81613416565b03611f065780806020019051810190611e9a919061342a565b6001600160a01b03166301e1d1146040518163ffffffff1660e01b81526004015f60405180830381865afa158015611ed4573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f19168201604052611efb9190810190613460565b935093505050915091565b5050915091565b5f5f5f5f5f611f1b866123e5565b50929650909450925090506001846009811115611f3a57611f3a613416565b03611fc1575f82806020019051810190611f54919061342a565b9050806001600160a01b0316636256f2c56040518163ffffffff1660e01b8152600401602060405180830381865afa158015611f92573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611fb69190613163565b979650505050505050565b610d09848484845f612412565b5f8260ff168460ff16111561200a575f611fe884866134fb565b611ff390600a6135f7565b90506120028660018386612049565b915050612041565b8260ff168460ff16101561203e5761202284846134fb565b61202d90600a6135f7565b6120379086612fb1565b9050612041565b50835b949350505050565b5f612076612056836124ad565b801561207157505f848061206c5761206c612fdc565b868809115b151590565b6120818686866124d9565b61191291906130e1565b5f67ffffffffffffffff821115611a2b57604080516306dfcc6560e41b8152600481019190915260248101839052604401611a22565b5f83515f036120d157505f612041565b8351600190868015612125575067ffffffffffffffff841685876120f6600185613003565b8151811061210657612106612fc8565b60200260200101516121189190613605565b67ffffffffffffffff1611155b8061217b57508615801561217b575067ffffffffffffffff8416858761214c600185613003565b8151811061215c5761215c612fc8565b602002602001015161216e9190613605565b67ffffffffffffffff1610155b156121945761218b600182613003565b92505050612041565b8082101561224b575f6121a78383612589565b9050876121ee578467ffffffffffffffff16868883815181106121cc576121cc612fc8565b60200260200101516121de9190613605565b67ffffffffffffffff161061222a565b8467ffffffffffffffff168688838151811061220c5761220c612fc8565b602002602001015161221e9190613605565b67ffffffffffffffff16115b1561223757809150612245565b6122428160016130e1565b92505b50612194565b611fb6600183613003565b5f7fcff34e096e1842f6f6ae4c0d0c6eefd4855c8bdc5bc64155d7c14b2dbeee661a5f1b888888888860405160200161228f9190613628565b60405160208183030381529060405280519060200120886040516020016122b6919061365d565b60408051601f198184030181528282528051602091820120908301989098526001600160a01b0396871690820152606081019490945293909116608083015260a082015260c081019190915260e0810191909152610100810183905261012001604051602081830303815290604052805190602001209050979650505050505050565b5f60608280602001905181019061235091906133c8565b9094909350915050565b5f5f60205f8451602086015f885af180612379576040513d5f823e3d81fd5b50505f513d9150811561239057806001141561239d565b6001600160a01b0384163b155b156123df576040517f5274afe70000000000000000000000000000000000000000000000000000000081526001600160a01b0385166004820152602401611a22565b50505050565b5f5f60608060608580602001905181019061240091906136a3565b939a9299509097509550909350915050565b5f5f61242786670de0b6b3a7640000866125a3565b90506124348782876125a3565b9150612448670de0b6b3a764000083612fb1565b61245a84670de0b6b3a7640000613003565b6124649083612fb1565b10801561249c575061247e83670de0b6b3a76400006130e1565b6124889082612fb1565b61249a670de0b6b3a764000084612fb1565b105b156101105796879650945050505050565b5f60028260038111156124c2576124c2613416565b6124cc9190613745565b60ff166001149050919050565b5f5f5f6124e686866129a1565b91509150815f0361250a5783818161250057612500612fdc565b04925050506108c5565b8184116125215761252160038515026011186129bd565b5f848688095f868103871696879004966002600389028118808a02820302808a02820302808a02820302808a02820302808a02820302808a02909103029181900381900460010185841190960395909502919093039390930492909217029150509392505050565b5f6125976002848418612ff0565b61022c908484166130e1565b5f808460098111156125b7576125b7613416565b03612687575f5f5f5f5f868060200190518101906125d59190613849565b945094509450945094505f6125ea828a6129ce565b86519091505f5b818110156126775761266d8389838151811061260f5761260f612fc8565b602002602001015188848151811061262957612629612fc8565b602002602001015188858151811061264357612643612fc8565b602002602001015160ff168b868151811061266057612660612fc8565b60200260200101516129fd565b92506001016125f1565b50819750505050505050506108c5565b600384600981111561269b5761269b613416565b036126af5750670de0b6b3a76400006108c5565b60028460098111156126c3576126c3613416565b036126cf5750816108c5565b60048460098111156126e3576126e3613416565b03612781576040517f7a28fb88000000000000000000000000000000000000000000000000000000008152670de0b6b3a7640000600482015273ae7ab96520de3a18e5e111b5eaab095312d7fe8490637a28fb8890602401602060405180830381865afa158015612756573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061277a9190613163565b90506108c5565b600584600981111561279557612795613416565b036127ea5773be9895146f7af43049ca1c1ae358b0541ea497046001600160a01b0316633ba0b9a96040518163ffffffff1660e01b8152600401602060405180830381865afa158015612756573d5f5f3e3d5ffd5b60068460098111156127fe576127fe613416565b036128535773ae78736cd615f374d3085123a210448e74fc63936001600160a01b031663e6aa216c6040518163ffffffff1660e01b8152600401602060405180830381865afa158015612756573d5f5f3e3d5ffd5b600784600981111561286757612867613416565b036128bc5773ac3e018457b222d93114458476f3e3416abbe38f6001600160a01b03166399530b066040518163ffffffff1660e01b8152600401602060405180830381865afa158015612756573d5f5f3e3d5ffd5b60088460098111156128d0576128d0613416565b036128f3575f828060200190518101906128ea9190613163565b91506108c59050565b600984600981111561290757612907613416565b0361299a575f5f838060200190518101906129229190613974565b9150915080826001600160a01b031663a035b1fe6040518163ffffffff1660e01b8152600401602060405180830381865afa158015612963573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906129879190613163565b6129919190612ff0565b925050506108c5565b50816108c5565b5f805f1983850993909202808410938190039390930393915050565b634e487b715f52806020526024601cfd5b5f808360018111156129e2576129e2613416565b036129f65750670de0b6b3a764000061022f565b508061022f565b5f5f5f866001600160a01b031663feaf968c6040518163ffffffff1660e01b815260040160a060405180830381865afa158015612a3c573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612a6091906139b9565b509350509250505f82131580612a84575063ffffffff8416612a828242613003565b115b15612abb576040517fae19356300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8560ff16600103612aee57612ad185600a6139fb565b612adb838a612fb1565b612ae59190612ff0565b92505050611912565b81612afa86600a6139fb565b612adb908a612fb1565b6001600160a01b0381168114612b18575f5ffd5b50565b634e487b7160e01b5f52604160045260245ffd5b60405160c0810167ffffffffffffffff81118282101715612b5257612b52612b1b565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715612b8157612b81612b1b565b604052919050565b5f67ffffffffffffffff821115612ba257612ba2612b1b565b5060051b60200190565b5f82601f830112612bbb575f5ffd5b8135612bce612bc982612b89565b612b58565b8082825260208201915060208360051b860101925085831115612bef575f5ffd5b602085015b83811015612c0c578035835260209283019201612bf4565b5095945050505050565b5f82601f830112612c25575f5ffd5b8135612c33612bc982612b89565b8082825260208201915060208360051b860101925085831115612c54575f5ffd5b602085015b83811015612c0c578035612c6c81612b04565b835260209283019201612c59565b5f5f5f5f5f60a08688031215612c8e575f5ffd5b853594506020860135612ca081612b04565b935060408601359250606086013567ffffffffffffffff811115612cc2575f5ffd5b612cce88828901612bac565b925050608086013567ffffffffffffffff811115612cea575f5ffd5b612cf688828901612c16565b9150509295509295909350565b5f8151808452602084019350602083015f5b82811015612d3c5781516001600160a01b0316865260209586019590910190600101612d15565b5093949350505050565b5f8151808452602084019350602083015f5b82811015612d3c578151865260209586019590910190600101612d58565b604081525f612d886040830185612d03565b82810360208401526119128185612d46565b5f67ffffffffffffffff821115612db357612db3612b1b565b50601f01601f191660200190565b5f5f5f5f5f5f60c08789031215612dd6575f5ffd5b863595506020870135612de881612b04565b945060408701359350606087013567ffffffffffffffff811115612e0a575f5ffd5b612e1689828a01612bac565b935050608087013567ffffffffffffffff811115612e32575f5ffd5b612e3e89828a01612c16565b92505060a087013567ffffffffffffffff811115612e5a575f5ffd5b8701601f81018913612e6a575f5ffd5b8035612e78612bc982612d9a565b8181528a6020838501011115612e8c575f5ffd5b816020840160208301375f602083830101528093505050509295509295509295565b5f5f5f5f60808587031215612ec1575f5ffd5b843593506020850135612ed381612b04565b925060408501359150606085013567ffffffffffffffff811115612ef5575f5ffd5b612f0187828801612bac565b91505092959194509250565b5f60208284031215612f1d575f5ffd5b5035919050565b8015158114612b18575f5ffd5b5f5f60408385031215612f42575f5ffd5b823591506020830135612f5481612f24565b809150509250929050565b848152608060208201525f612f776080830186612d03565b8281036040840152612f898186612d46565b90508281036060840152611fb68185612d03565b634e487b7160e01b5f52601160045260245ffd5b808202811582820484141761022f5761022f612f9d565b634e487b7160e01b5f52603260045260245ffd5b634e487b7160e01b5f52601260045260245ffd5b5f82612ffe57612ffe612fdc565b500490565b8181038181111561022f5761022f612f9d565b5f5f85851115613024575f5ffd5b83861115613030575f5ffd5b5050820193919092039150565b80357fffffffff00000000000000000000000000000000000000000000000000000000811690600484101561309c577fffffffff00000000000000000000000000000000000000000000000000000000808560040360031b1b82161691505b5092915050565b6001600160a01b038416815260406020820152816040820152818360608301375f818301606090810191909152601f909201601f1916010192915050565b8082018082111561022f5761022f612f9d565b6001600160801b03818116838216019081111561022f5761022f612f9d565b600181811c9082168061312757607f821691505b60208210810361314557634e487b7160e01b5f52602260045260245ffd5b50919050565b5f6001820161315c5761315c612f9d565b5060010190565b5f60208284031215613173575f5ffd5b5051919050565b67ffffffffffffffff828116828216039081111561022f5761022f612f9d565b600782810b9082900b03677fffffffffffffff198112677fffffffffffffff8213171561022f5761022f612f9d565b5f8260070b8260070b028060070b915080821461309c5761309c612f9d565b5f8160070b8360070b806131fe576131fe612fdc565b677fffffffffffffff1982145f198214161561321c5761321c612f9d565b90059392505050565b600781810b9083900b01677fffffffffffffff8113677fffffffffffffff198212171561022f5761022f612f9d565b5f82601f830112613263575f5ffd5b8151613271612bc982612d9a565b818152846020838601011115613285575f5ffd5b8160208501602083015e5f918101602001919091529392505050565b5f602082840312156132b1575f5ffd5b815167ffffffffffffffff8111156132c7575f5ffd5b820160c081850312156132d8575f5ffd5b6132e0612b2f565b81516132eb81612b04565b81526020828101519082015260408083015190820152606080830151908201526080808301519082015260a082015167ffffffffffffffff81111561332e575f5ffd5b61333a86828501613254565b60a083015250949350505050565b6001600160a01b03881681526001600160a01b03871660208201528560408201528460608201528360808201528260a082015260e060c08201525f82518060e0840152806020850161010085015e5f6101008285010152610100601f19601f83011684010191505098975050505050505050565b60018110612b18575f5ffd5b5f5f604083850312156133d9575f5ffd5b82516133e4816133bc565b602084015190925067ffffffffffffffff811115613400575f5ffd5b61340c85828601613254565b9150509250929050565b634e487b7160e01b5f52602160045260245ffd5b5f6020828403121561343a575f5ffd5b81516108c581612b04565b5f60208284031215613455575f5ffd5b81516108c581612f24565b5f5f60408385031215613471575f5ffd5b825167ffffffffffffffff811115613487575f5ffd5b8301601f81018513613497575f5ffd5b80516134a5612bc982612b89565b8082825260208201915060208360051b8501019250878311156134c6575f5ffd5b6020840193505b828410156134e85783518252602093840193909101906134cd565b6020969096015195979596505050505050565b60ff828116828216039081111561022f5761022f612f9d565b6001815b600184111561354f5780850481111561353357613533612f9d565b600184161561354157908102905b60019390931c928002613518565b935093915050565b5f826135655750600161022f565b8161357157505f61022f565b81600181146135875760028114613591576135ad565b600191505061022f565b60ff8411156135a2576135a2612f9d565b50506001821b61022f565b5060208310610133831016604e8410600b84101617156135d0575081810a61022f565b6135dc5f198484613514565b805f19048211156135ef576135ef612f9d565b029392505050565b5f61022c60ff841683613557565b67ffffffffffffffff818116838216029081169081811461309c5761309c612f9d565b81515f90829060208501835b82811015613652578151845260209384019390910190600101613634565b509195945050505050565b81515f90829060208501835b828110156136525781516001600160a01b0316845260209384019390910190600101613669565b8051600a811061369e575f5ffd5b919050565b5f5f5f5f5f60a086880312156136b7575f5ffd5b6136c086613690565b94506136ce60208701613690565b9350604086015167ffffffffffffffff8111156136e9575f5ffd5b6136f588828901613254565b935050606086015167ffffffffffffffff811115613711575f5ffd5b61371d88828901613254565b925050608086015167ffffffffffffffff811115613739575f5ffd5b612cf688828901613254565b5f60ff83168061375757613757612fdc565b8060ff84160691505092915050565b5f82601f830112613775575f5ffd5b8151613783612bc982612b89565b8082825260208201915060208360051b8601019250858311156137a4575f5ffd5b602085015b83811015612c0c57805163ffffffff811681146137c4575f5ffd5b8352602092830192016137a9565b5f82601f8301126137e1575f5ffd5b81516137ef612bc982612b89565b8082825260208201915060208360051b860101925085831115613810575f5ffd5b602085015b83811015612c0c57805160ff8116811461382d575f5ffd5b835260209283019201613815565b80516002811061369e575f5ffd5b5f5f5f5f5f60a0868803121561385d575f5ffd5b855167ffffffffffffffff811115613873575f5ffd5b8601601f81018813613883575f5ffd5b8051613891612bc982612b89565b8082825260208201915060208360051b85010192508a8311156138b2575f5ffd5b6020840193505b828410156138dd5783516138cc81612b04565b8252602093840193909101906138b9565b80985050505050602086015167ffffffffffffffff8111156138fd575f5ffd5b61390988828901613766565b945050604086015167ffffffffffffffff811115613925575f5ffd5b613931888289016137d2565b935050606086015167ffffffffffffffff81111561394d575f5ffd5b613959888289016137d2565b9250506139686080870161383b565b90509295509295909350565b5f5f60408385031215613985575f5ffd5b825161399081612b04565b6020939093015192949293505050565b805169ffffffffffffffffffff8116811461369e575f5ffd5b5f5f5f5f5f60a086880312156139cd575f5ffd5b6139d6866139a0565b60208701516040880151606089015192975090955093509150613968608087016139a0565b5f61022c838361355756fe4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75a2646970667358221220adec1ca214a5a3cf42d22772187300cfb66c2131f2ea0b391dd08d79bc15ddb564736f6c634300081c0033",
+  "bytecode": "0x6080604052348015600e575f5ffd5b50613b148061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610064575f3560e01c8063d703a0cd1161004d578063d703a0cd146100a5578063f70125ab146100b8578063fd7daaf8146100cb575f5ffd5b80632c1918f914610068578063b521934614610092575b5f5ffd5b61007b610076366004612cf8565b6100ec565b604051610089929190612dfe565b60405180910390f35b61007b6100a0366004612e22565b61011b565b61007b6100b3366004612e88565b610174565b61007b6100c6366004612f13565b61018b565b6100de6100d9366004612fdc565b6101ad565b604051908152602001610089565b60608061010c88888888888860405180602001604052805f81525061023b565b91509150965096945050505050565b606080610165878787875f60405190808252806020026020018201604052801561014f578160200160208202803683370190505b508860405180602001604052805f81525061023b565b915091505b9550959350505050565b6060806101808361054d565b509094909350915050565b60608061019d8989898989898961023b565b9150915097509795505050505050565b5f6101b9335f366107fe565b1580156101f15750335f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7b6020526040902054155b15610228576040517fc22a648e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6102328383610937565b90505b92915050565b5f516020613abf5f395f51905f528054606091829160ff600160a81b9091041660011901610295576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff60a81b191675020000000000000000000000000000000000000000001781555f516020613abf5f395f51905f525474010000000000000000000000000000000000000000900460ff165f0361031a576040517f9e87fac800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b87421115610354576040517fecdd1c2900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103ab6040518061010001604052805f81526020015f6001600160a01b031681526020015f6001600160a01b0316815260200160608152602001606081526020016060815260200160608152602001606081525090565b8a81526001600160a01b038a16604082015260c0810188905260e081018790526103d48b61054d565b60a08401526080830181905260608301919091528851905114610423576040517f1df89e8b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b858160600151604051602001610439919061300a565b6040516020818303038152906040528051906020012014610486576040517f580e8a7900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6104908b5f610937565b506104a08b8b8b8b8b8b8b610c81565b6001600160a01b031660208201526104b781610d81565b80604001516001600160a01b031681602001516001600160a01b03167f3998bcf315dae4953d294b3ca6e1d0074c249adc136b50d1ff99b04753c73e7f835f0151846060015185608001518660e001516040516105179493929190613048565b60405180910390a3806060015181608001519350935050805460ff60a81b1916600160a81b179055909890975095505050505050565b60608060605f5f61055c6111a1565b9198509650945090925090508086106105875760405162839e0f60e81b815260040160405180910390fd5b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c798054604080516020808402820181019092528281525f516020613abf5f395f51905f52935f93919290919083018282801561062257602002820191905f5260205f20905f905b825461010083900a900460070b81526020600f83018190049384019360010360089093019290920291018084116105ee5790505b505050505090505f633b9aca008567ffffffffffffffff1610156106d6575f836003018054806020026020016040519081016040528092919081815260200182805480156106c057602002820191905f5260205f20905f905b82829054906101000a900467ffffffffffffffff1667ffffffffffffffff168152602001906008019060208260070104928301926001038202915080841161067b5790505b505050505090506106d28682856117e8565b9150505b5f5b87518110156107f157633b9aca008667ffffffffffffffff16101561074e57610705633b9aca008661309a565b8267ffffffffffffffff16898381518110610722576107226130b1565b60200260200101518c610735919061309a565b61073f919061309a565b61074991906130d9565b6107cc565b61076267ffffffffffffffff87168661309a565b836001855161077191906130ec565b81518110610781576107816130b1565b602002602001015167ffffffffffffffff168983815181106107a5576107a56130b1565b60200260200101518c6107b8919061309a565b6107c2919061309a565b6107cc91906130d9565b8882815181106107de576107de6130b1565b60209081029190910101526001016106d8565b5050505050509193909250565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d545f906001600160a01b0316818061084e8388306108406004868b8d6130ff565b61084991613126565b611988565b91509150816109285763ffffffff81161561091d575f516020613abf5f395f51905f52805460ff60b01b19167601000000000000000000000000000000000000000000001781556040517f94c7d7ee0000000000000000000000000000000000000000000000000000000081526001600160a01b038516906394c7d7ee906108de908b908b908b9060040161318c565b5f604051808303815f87803b1580156108f5575f5ffd5b505af1158015610907573d5f5f3e3d5ffd5b5050825460ff60b01b1916909255506109289050565b5f9350505050610930565b600193505050505b9392505050565b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c76545f905f516020613abf5f395f51905f52906001600160801b03600160801b82048116911684156109b5578061099a6b033b2e3c9fd0803ce80000008861309a565b6109a491906130d9565b6109ae90836131ca565b93506109e3565b806109cc6b033b2e3c9fd0803ce80000008861309a565b6109d691906130d9565b6109e090836130ec565b93505b670de0b6b3a764000084111580610a0957506ec097ce7bc90715b34b9f10000000008410155b15610be7575f83600201805480602002602001604051908101604052809291908181526020018280548015610a6557602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610a47575b505050505090505f815190505f5f5b82811015610b9a575f610b076b033b2e3c9fd0803ce80000008a8a6005015f898781518110610aa557610aa56130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f2054610af891906501000000000090047affffffffffffffffffffffffffffffffffffffffffffffffffffff1661309a565b610b0291906130d9565b611a60565b9050610b1381846131dd565b9250806001600160801b0316886005015f878581518110610b3657610b366130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f2080547affffffffffffffffffffffffffffffffffffffffffffffffffffff92909216650100000000000264ffffffffff90921691909117905550600101610a74565b506001860180547fffffffffffffffffffffffffffffffff00000000000000000000000000000000166001600160801b0392909216919091179055506b033b2e3c9fd0803ce80000009450505b610bf084611a60565b6001840180546001600160801b03928316600160801b02921691909117905584158015610c28575060018301546001600160801b0316155b15610c455760405162839e0f60e81b815260040160405180910390fd5b6040518481527fb4fde7403c001c7cdeafc0c3bb46e972111b7efac4e832398cbf9fabe1694ed99060200160405180910390a150505092915050565b5f516020613abf5f395f51905f525481515f916001600160a01b03169015610d1557610cb289898989898989611a9c565b6040516315a38ec760e11b8152600481018b90523060248201529092506001600160a01b03821690632b471d8e906044015f604051808303815f87803b158015610cfa575f5ffd5b505af1158015610d0c573d5f5f3e3d5ffd5b50505050610d75565b6040516315a38ec760e11b8152600481018a9052336024820181905292506001600160a01b03821690632b471d8e906044015f604051808303815f87803b158015610d5e575f5ffd5b505af1158015610d70573d5f5f3e3d5ffd5b505050505b50979650505050505050565b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c778054604080516020808402820181019092528281525f516020613abf5f395f51905f52935f939192909190830182828015610e0457602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610de6575b505050505090505f5f84608001515190505f5b81811015611199578560c001518181518110610e3557610e356130b1565b602002602001015186608001518281518110610e5357610e536130b1565b60200260200101511015610e93576040517fa1aabbe100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f86608001518281518110610eaa57610eaa6130b1565b6020026020010151118015610ee857505f610ee687606001518381518110610ed457610ed46130b1565b60200260200101518860e00151611bba565b125b15611155575f856005015f868681518110610f0557610f056130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f208054909150640100000000900460ff1615801590610fda5750610fd8816006018054610f52906131fc565b80601f0160208091040260200160405190810160405280929190818152602001828054610f7e906131fc565b8015610fc95780601f10610fa057610100808354040283529160200191610fc9565b820191905f5260205f20905b815481529060010190602001808311610fac57829003601f168201915b50505050508860400151611c16565b155b15611011576040517f584a793800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff16156110f7576110f287606001518381518110611034576110346130b1565b6020026020010151886040015189608001518581518110611057576110576130b1565b6020026020010151846007016001018054611071906131fc565b80601f016020809104026020016040519081016040528092919081815260200182805461109d906131fc565b80156110e85780601f106110bf576101008083540402835291602001916110e8565b820191905f5260205f20905b8154815290600101906020018083116110cb57829003601f168201915b5050505050611d87565b611153565b611153876040015188608001518481518110611115576111156130b1565b602002602001015189606001518581518110611133576111336130b1565b60200260200101516001600160a01b0316611e489092919063ffffffff16565b505b8060018760a00151858151811061116e5761116e6130b1565b602002602001015161118091906130ec565b116111915761118e83613234565b92505b600101610e17565b505050505050565b5f8060608080835f516020613abf5f395f51905f5290505f5f8260020180548060200260200160405190810160405280929190818152602001828054801561121057602002820191905f5260205f20905b81546001600160a01b031681526001909101906020018083116111f2575b505050505090505f815190505f8167ffffffffffffffff81111561123657611236612b99565b60405190808252806020026020018201604052801561125f578160200160208202803683370190505b5095505f5b8281101561133157856005015f858381518110611283576112836130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f9081205460ff1690036112c1576112ba82613234565b915061130b565b856005015f8583815181106112d8576112d86130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f206007015461130890836131ca565b91505b8187828151811061131e5761131e6130b1565b6020908102919091010152600101611264565b508067ffffffffffffffff81111561134b5761134b612b99565b604051908082528060200260200182016040528015611374578160200160208202803683370190505b5096508067ffffffffffffffff81111561139057611390612b99565b6040519080825280602002602001820160405280156113b9578160200160208202803683370190505b5097505f5f5b83811015611774575f876005015f8784815181106113df576113df6130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f908120805490925060ff161561157d5760606114a8836007016001018054611427906131fc565b80601f0160208091040260200160405190810160405280929190818152602001828054611453906131fc565b801561149e5780601f106114755761010080835404028352916020019161149e565b820191905f5260205f20905b81548152906001019060200180831161148157829003601f168201915b5050505050611ecd565b81519093509091505f5b8181101561156957600785018054829081106114d0576114d06130b1565b5f918252602090912001546001600160a01b03168f6114ef838a6131ca565b815181106114ff576114ff6130b1565b60200260200101906001600160a01b031690816001600160a01b031681525050828181518110611531576115316130b1565b60200260200101518e828961154691906131ca565b81518110611556576115566130b1565b60209081029190910101526001016114b2565b5061157481876131ca565b9550505061168b565b86838151811061158f5761158f6130b1565b60209081029190910101516040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa1580156115f6573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061161a919061324c565b905086838151811061162e5761162e6130b1565b60200260200101518c8581518110611648576116486130b1565b6001600160a01b0390921660209283029190910190910152808b8561166c81613234565b96508151811061167e5761167e6130b1565b6020026020010181815250505b5f61171f83600501805461169e906131fc565b80601f01602080910402602001604051908101604052809291908181526020018280546116ca906131fc565b80156117155780601f106116ec57610100808354040283529160200191611715565b820191905f5260205f20905b8154815290600101906020018083116116f857829003601f168201915b5050505050611f7c565b8354909150670de0b6b3a7640000906117469084906301000000900460ff1660125f612048565b611750908361309a565b61175a91906130d9565b611764908a6131ca565b98505050508060010190506113bf565b50506001808601546117a8916001600160801b0380831692600160801b900416906b033b2e3c9fd0803ce8000000906120c3565b985088156117d0576117c96117c485633b9aca008c60016120c3565b612105565b99506117dc565b67ffffffffffffffff99505b50505050509091929394565b5f5f6117f860018560018861213b565b9050801580156118345750835f81518110611815576118156130b1565b602002602001015167ffffffffffffffff168567ffffffffffffffff16105b1561185b57825f8151811061184b5761184b6130b1565b6020026020010151915050610930565b6001845161186991906130ec565b810361188e57826001855161187e91906130ec565b8151811061184b5761184b6130b1565b8381815181106118a0576118a06130b1565b6020026020010151848260016118b691906131ca565b815181106118c6576118c66130b1565b60200260200101516118d89190613263565b8482815181106118ea576118ea6130b1565b6020026020010151866118fd9190613263565b84838151811061190f5761190f6130b1565b60200260200101518584600161192591906131ca565b81518110611935576119356130b1565b60200260200101516119479190613283565b61195191906132b2565b61195b91906132d1565b83828151811061196d5761196d6130b1565b602002602001015161197f919061330e565b95945050505050565b6040516001600160a01b038085166024830152831660448201527fffffffff00000000000000000000000000000000000000000000000000000000821660648201525f908190819060840160408051601f19818403018152918152602080830180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fb7009613000000000000000000000000000000000000000000000000000000001781525f808052918290528351939450919290918a5afa15611a56575f516020805191945081901c150291505b5094509492505050565b5f6001600160801b03821115611a98576040516306dfcc6560e41b815260806004820152602481018390526044015b60405180910390fd5b5090565b5f5f82806020019051810190611ab2919061338a565b905088816020015114611af1576040517f1115766700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f611b09825f01518b8b8b8b8b8b89608001516122d0565b5f516020613abf5f395f51905f525483516020850151604080870151606088015160a089015192517f88b7ab630000000000000000000000000000000000000000000000000000000081529697506001600160a01b03909516956388b7ab6395611b7e959430949093928a9190600401613431565b5f604051808303815f87803b158015611b95575f5ffd5b505af1158015611ba7573d5f5f3e3d5ffd5b505092519b9a5050505050505050505050565b80515f90815b81811015611c0b57838181518110611bda57611bda6130b1565b60200260200101516001600160a01b0316856001600160a01b031603611c035791506102359050565b600101611bc0565b505f19949350505050565b5f5f5f84806020019051810190611c2d91906134b1565b915091505f611c465f516020613abf5f395f51905f5290565b6008015f848015611c5957611c596134ff565b8015611c6757611c676134ff565b81526020019081526020015f205f866001600160a01b03166001600160a01b031681526020019081526020015f20541115611ca757600192505050610235565b805115611d7d575f828015611cbe57611cbe6134ff565b03611d7d575f81806020019051810190611cd89190613513565b90506001600160a01b03811615611d7b576040517f65e4ad9e0000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b0386811660248301528216906365e4ad9e906044016020604051808303815f875af1158015611d4d573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611d71919061352e565b9350505050610235565b505b505f949350505050565b5f5f611d92836123b7565b90925090505f828015611da757611da76134ff565b036111995780806020019051810190611dc09190613513565b6040517f8bfb07c90000000000000000000000000000000000000000000000000000000081526001600160a01b0388811660048301528781166024830152604482018790529190911690638bfb07c9906064015f604051808303815f87803b158015611e2a575f5ffd5b505af1158015611e3c573d5f5f3e3d5ffd5b50505050505050505050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052611ec89084906123d8565b505050565b60605f5f5f611edb856123b7565b90925090505f828015611ef057611ef06134ff565b03611f755780806020019051810190611f099190613513565b6001600160a01b03166301e1d1146040518163ffffffff1660e01b81526004015f60405180830381865afa158015611f43573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f19168201604052611f6a9190810190613549565b935093505050915091565b5050915091565b5f5f5f5f5f611f8a86612463565b50929650909450925090506001846009811115611fa957611fa96134ff565b03612030575f82806020019051810190611fc39190613513565b9050806001600160a01b0316636256f2c56040518163ffffffff1660e01b8152600401602060405180830381865afa158015612001573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612025919061324c565b979650505050505050565b61203d848484845f612490565b509695505050505050565b5f8260ff168460ff161115612084575f61206284866135e4565b61206d90600a6136e0565b905061207c86600183866120c3565b9150506120bb565b8260ff168460ff1610156120b85761209c84846135e4565b6120a790600a6136e0565b6120b1908661309a565b90506120bb565b50835b949350505050565b5f6120f06120d08361252b565b80156120eb57505f84806120e6576120e66130c5565b868809115b151590565b6120fb868686612557565b61197f91906131ca565b5f67ffffffffffffffff821115611a9857604080516306dfcc6560e41b8152600481019190915260248101839052604401611a8f565b5f83515f0361214b57505f6120bb565b835160019086801561219f575067ffffffffffffffff841685876121706001856130ec565b81518110612180576121806130b1565b602002602001015161219291906136ee565b67ffffffffffffffff1611155b806121f55750861580156121f5575067ffffffffffffffff841685876121c66001856130ec565b815181106121d6576121d66130b1565b60200260200101516121e891906136ee565b67ffffffffffffffff1610155b1561220e576122056001826130ec565b925050506120bb565b808210156122c5575f6122218383612607565b905087612268578467ffffffffffffffff1686888381518110612246576122466130b1565b602002602001015161225891906136ee565b67ffffffffffffffff16106122a4565b8467ffffffffffffffff1686888381518110612286576122866130b1565b602002602001015161229891906136ee565b67ffffffffffffffff16115b156122b1578091506122bf565b6122bc8160016131ca565b92505b5061220e565b6120256001836130ec565b5f7fb6577f08e668b53303325a19233e8315142d69bedb6d7e1d8d0e9af2473486d45f1b89898989896040516020016123099190613711565b6040516020818303038152906040528051906020012089604051602001612330919061300a565b60408051808303601f190181528282528051602091820120818401999099526001600160a01b0397881683830152606083019690965293909516608086015260a085019190915260c084015260e083019390935261010082019590955261012080820194909452815180820390940184526101400190525080519101209695505050505050565b5f6060828060200190518101906123ce91906134b1565b9094909350915050565b5f5f60205f8451602086015f885af1806123f7576040513d5f823e3d81fd5b50505f513d9150811561240e57806001141561241b565b6001600160a01b0384163b155b1561245d576040517f5274afe70000000000000000000000000000000000000000000000000000000081526001600160a01b0385166004820152602401611a8f565b50505050565b5f5f60608060608580602001905181019061247e919061374e565b939a9299509097509550909350915050565b5f5f6124a586670de0b6b3a764000086612621565b90506124b2878287612621565b91506124c6670de0b6b3a76400008361309a565b6124d884670de0b6b3a76400006130ec565b6124e2908361309a565b10801561251a57506124fc83670de0b6b3a76400006131ca565b612506908261309a565b612518670de0b6b3a76400008461309a565b105b1561016a5796879650945050505050565b5f6002826003811115612540576125406134ff565b61254a91906137fd565b60ff166001149050919050565b5f5f5f6125648686612a1f565b91509150815f036125885783818161257e5761257e6130c5565b0492505050610930565b81841161259f5761259f6003851502601118612a3b565b5f848688095f868103871696879004966002600389028118808a02820302808a02820302808a02820302808a02820302808a02820302808a02909103029181900381900460010185841190960395909502919093039390930492909217029150509392505050565b5f61261560028484186130d9565b610232908484166131ca565b5f80846009811115612635576126356134ff565b03612705575f5f5f5f5f868060200190518101906126539190613901565b945094509450945094505f612668828a612a4c565b86519091505f5b818110156126f5576126eb8389838151811061268d5761268d6130b1565b60200260200101518884815181106126a7576126a76130b1565b60200260200101518885815181106126c1576126c16130b1565b602002602001015160ff168b86815181106126de576126de6130b1565b6020026020010151612a7b565b925060010161266f565b5081975050505050505050610930565b6003846009811115612719576127196134ff565b0361272d5750670de0b6b3a7640000610930565b6002846009811115612741576127416134ff565b0361274d575081610930565b6004846009811115612761576127616134ff565b036127ff576040517f7a28fb88000000000000000000000000000000000000000000000000000000008152670de0b6b3a7640000600482015273ae7ab96520de3a18e5e111b5eaab095312d7fe8490637a28fb8890602401602060405180830381865afa1580156127d4573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906127f8919061324c565b9050610930565b6005846009811115612813576128136134ff565b036128685773be9895146f7af43049ca1c1ae358b0541ea497046001600160a01b0316633ba0b9a96040518163ffffffff1660e01b8152600401602060405180830381865afa1580156127d4573d5f5f3e3d5ffd5b600684600981111561287c5761287c6134ff565b036128d15773ae78736cd615f374d3085123a210448e74fc63936001600160a01b031663e6aa216c6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156127d4573d5f5f3e3d5ffd5b60078460098111156128e5576128e56134ff565b0361293a5773ac3e018457b222d93114458476f3e3416abbe38f6001600160a01b03166399530b066040518163ffffffff1660e01b8152600401602060405180830381865afa1580156127d4573d5f5f3e3d5ffd5b600884600981111561294e5761294e6134ff565b03612971575f82806020019051810190612968919061324c565b91506109309050565b6009846009811115612985576129856134ff565b03612a18575f5f838060200190518101906129a09190613a2c565b9150915080826001600160a01b031663a035b1fe6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156129e1573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612a05919061324c565b612a0f91906130d9565b92505050610930565b5081610930565b5f805f1983850993909202808410938190039390930393915050565b634e487b715f52806020526024601cfd5b5f80836001811115612a6057612a606134ff565b03612a745750670de0b6b3a7640000610235565b5080610235565b5f5f5f866001600160a01b031663feaf968c6040518163ffffffff1660e01b815260040160a060405180830381865afa158015612aba573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612ade9190613a71565b509350509250505f82131580612b02575063ffffffff8416612b0082426130ec565b115b15612b39576040517fae19356300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8560ff16600103612b6c57612b4f85600a613ab3565b612b59838a61309a565b612b6391906130d9565b9250505061197f565b81612b7886600a613ab3565b612b59908a61309a565b6001600160a01b0381168114612b96575f5ffd5b50565b634e487b7160e01b5f52604160045260245ffd5b60405160c0810167ffffffffffffffff81118282101715612bd057612bd0612b99565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715612bff57612bff612b99565b604052919050565b5f67ffffffffffffffff821115612c2057612c20612b99565b5060051b60200190565b5f82601f830112612c39575f5ffd5b8135612c4c612c4782612c07565b612bd6565b8082825260208201915060208360051b860101925085831115612c6d575f5ffd5b602085015b83811015612c8a578035835260209283019201612c72565b5095945050505050565b5f82601f830112612ca3575f5ffd5b8135612cb1612c4782612c07565b8082825260208201915060208360051b860101925085831115612cd2575f5ffd5b602085015b83811015612c8a578035612cea81612b82565b835260209283019201612cd7565b5f5f5f5f5f5f60c08789031215612d0d575f5ffd5b863595506020870135612d1f81612b82565b945060408701359350606087013567ffffffffffffffff811115612d41575f5ffd5b612d4d89828a01612c2a565b935050608087013567ffffffffffffffff811115612d69575f5ffd5b612d7589828a01612c94565b9699959850939692959460a09093013593505050565b5f8151808452602084019350602083015f5b82811015612dc45781516001600160a01b0316865260209586019590910190600101612d9d565b5093949350505050565b5f8151808452602084019350602083015f5b82811015612dc4578151865260209586019590910190600101612de0565b604081525f612e106040830185612d8b565b828103602084015261197f8185612dce565b5f5f5f5f5f60a08688031215612e36575f5ffd5b853594506020860135612e4881612b82565b935060408601359250606086013567ffffffffffffffff811115612e6a575f5ffd5b612e7688828901612c2a565b95989497509295608001359392505050565b5f60208284031215612e98575f5ffd5b5035919050565b5f67ffffffffffffffff821115612eb857612eb8612b99565b50601f01601f191660200190565b5f82601f830112612ed5575f5ffd5b8135612ee3612c4782612e9f565b818152846020838601011115612ef7575f5ffd5b816020850160208301375f918101602001919091529392505050565b5f5f5f5f5f5f5f60e0888a031215612f29575f5ffd5b873596506020880135612f3b81612b82565b955060408801359450606088013567ffffffffffffffff811115612f5d575f5ffd5b612f698a828b01612c2a565b945050608088013567ffffffffffffffff811115612f85575f5ffd5b612f918a828b01612c94565b93505060a0880135915060c088013567ffffffffffffffff811115612fb4575f5ffd5b612fc08a828b01612ec6565b91505092959891949750929550565b8015158114612b96575f5ffd5b5f5f60408385031215612fed575f5ffd5b823591506020830135612fff81612fcf565b809150509250929050565b81515f90829060208501835b8281101561303d5781516001600160a01b0316845260209384019390910190600101613016565b509195945050505050565b848152608060208201525f6130606080830186612d8b565b82810360408401526130728186612dce565b905082810360608401526120258185612d8b565b634e487b7160e01b5f52601160045260245ffd5b808202811582820484141761023557610235613086565b634e487b7160e01b5f52603260045260245ffd5b634e487b7160e01b5f52601260045260245ffd5b5f826130e7576130e76130c5565b500490565b8181038181111561023557610235613086565b5f5f8585111561310d575f5ffd5b83861115613119575f5ffd5b5050820193919092039150565b80357fffffffff000000000000000000000000000000000000000000000000000000008116906004841015613185577fffffffff00000000000000000000000000000000000000000000000000000000808560040360031b1b82161691505b5092915050565b6001600160a01b038416815260406020820152816040820152818360608301375f818301606090810191909152601f909201601f1916010192915050565b8082018082111561023557610235613086565b6001600160801b03818116838216019081111561023557610235613086565b600181811c9082168061321057607f821691505b60208210810361322e57634e487b7160e01b5f52602260045260245ffd5b50919050565b5f6001820161324557613245613086565b5060010190565b5f6020828403121561325c575f5ffd5b5051919050565b67ffffffffffffffff828116828216039081111561023557610235613086565b600782810b9082900b03677fffffffffffffff198112677fffffffffffffff8213171561023557610235613086565b5f8260070b8260070b028060070b915080821461318557613185613086565b5f8160070b8360070b806132e7576132e76130c5565b677fffffffffffffff1982145f198214161561330557613305613086565b90059392505050565b600781810b9083900b01677fffffffffffffff8113677fffffffffffffff198212171561023557610235613086565b5f82601f83011261334c575f5ffd5b815161335a612c4782612e9f565b81815284602083860101111561336e575f5ffd5b8160208501602083015e5f918101602001919091529392505050565b5f6020828403121561339a575f5ffd5b815167ffffffffffffffff8111156133b0575f5ffd5b820160c081850312156133c1575f5ffd5b6133c9612bad565b81516133d481612b82565b81526020828101519082015260408083015190820152606080830151908201526080808301519082015260a082015167ffffffffffffffff811115613417575f5ffd5b6134238682850161333d565b60a083015250949350505050565b6001600160a01b03881681526001600160a01b03871660208201528560408201528460608201528360808201528260a082015260e060c08201525f82518060e0840152806020850161010085015e5f6101008285010152610100601f19601f83011684010191505098975050505050505050565b60018110612b96575f5ffd5b5f5f604083850312156134c2575f5ffd5b82516134cd816134a5565b602084015190925067ffffffffffffffff8111156134e9575f5ffd5b6134f58582860161333d565b9150509250929050565b634e487b7160e01b5f52602160045260245ffd5b5f60208284031215613523575f5ffd5b815161093081612b82565b5f6020828403121561353e575f5ffd5b815161093081612fcf565b5f5f6040838503121561355a575f5ffd5b825167ffffffffffffffff811115613570575f5ffd5b8301601f81018513613580575f5ffd5b805161358e612c4782612c07565b8082825260208201915060208360051b8501019250878311156135af575f5ffd5b6020840193505b828410156135d15783518252602093840193909101906135b6565b6020969096015195979596505050505050565b60ff828116828216039081111561023557610235613086565b6001815b60018411156136385780850481111561361c5761361c613086565b600184161561362a57908102905b60019390931c928002613601565b935093915050565b5f8261364e57506001610235565b8161365a57505f610235565b8160018114613670576002811461367a57613696565b6001915050610235565b60ff84111561368b5761368b613086565b50506001821b610235565b5060208310610133831016604e8410600b84101617156136b9575081810a610235565b6136c55f1984846135fd565b805f19048211156136d8576136d8613086565b029392505050565b5f61023260ff841683613640565b67ffffffffffffffff818116838216029081169081811461318557613185613086565b81515f90829060208501835b8281101561303d57815184526020938401939091019060010161371d565b8051600a8110613749575f5ffd5b919050565b5f5f5f5f5f60a08688031215613762575f5ffd5b61376b8661373b565b94506137796020870161373b565b9350604086015167ffffffffffffffff811115613794575f5ffd5b6137a08882890161333d565b935050606086015167ffffffffffffffff8111156137bc575f5ffd5b6137c88882890161333d565b925050608086015167ffffffffffffffff8111156137e4575f5ffd5b6137f08882890161333d565b9150509295509295909350565b5f60ff83168061380f5761380f6130c5565b8060ff84160691505092915050565b5f82601f83011261382d575f5ffd5b815161383b612c4782612c07565b8082825260208201915060208360051b86010192508583111561385c575f5ffd5b602085015b83811015612c8a57805163ffffffff8116811461387c575f5ffd5b835260209283019201613861565b5f82601f830112613899575f5ffd5b81516138a7612c4782612c07565b8082825260208201915060208360051b8601019250858311156138c8575f5ffd5b602085015b83811015612c8a57805160ff811681146138e5575f5ffd5b8352602092830192016138cd565b805160028110613749575f5ffd5b5f5f5f5f5f60a08688031215613915575f5ffd5b855167ffffffffffffffff81111561392b575f5ffd5b8601601f8101881361393b575f5ffd5b8051613949612c4782612c07565b8082825260208201915060208360051b85010192508a83111561396a575f5ffd5b6020840193505b8284101561399557835161398481612b82565b825260209384019390910190613971565b80985050505050602086015167ffffffffffffffff8111156139b5575f5ffd5b6139c18882890161381e565b945050604086015167ffffffffffffffff8111156139dd575f5ffd5b6139e98882890161388a565b935050606086015167ffffffffffffffff811115613a05575f5ffd5b613a118882890161388a565b925050613a20608087016138f3565b90509295509295909350565b5f5f60408385031215613a3d575f5ffd5b8251613a4881612b82565b6020939093015192949293505050565b805169ffffffffffffffffffff81168114613749575f5ffd5b5f5f5f5f5f60a08688031215613a85575f5ffd5b613a8e86613a58565b60208701516040880151606089015192975090955093509150613a2060808701613a58565b5f610232838361364056fe4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75a2646970667358221220b7fbf7d6a933c486c1d974bb6f124b67553467f098ad407daa4edc583ab3f08764736f6c634300081c0033",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -347,10 +367,11 @@
           "tokens": "List of tokens that would be given"
         }
       },
-      "redeem(uint256,address,uint256,uint256[])": {
+      "redeem(uint256,address,uint256,uint256[],bytes32)": {
         "details": "The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function",
         "params": {
           "deadline": "Timestamp before which the redemption should have occured",
+          "expectedTokensHash": "`keccak256(abi.encodePacked(tokens))` over the output list the caller was quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since `minAmountOuts` is positional and a collateral rotation can change which token each entry protects",
           "minAmountOuts": "Minimum amount of each token given back in the redemption to obtain",
           "receiver": "Address which should be receiving the output tokens"
         },
@@ -359,10 +380,10 @@
           "tokens": "List of tokens returned"
         }
       },
-      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": {
-        "details": "The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`."
+      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": {
+        "details": "The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.`expectedTokensHash` matters most here: a signature stays executable for its whole validity window, so without it a relayer could hold one until a collateral rotation reshuffles the output list"
       },
-      "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": {
+      "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": {
         "details": "Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount"
       },
       "updateNormalizer(uint256,bool)": {
@@ -375,28 +396,28 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "2988000",
-        "executionCost": "3276",
-        "totalCost": "2991276"
+        "codeDepositCost": "3024800",
+        "executionCost": "3323",
+        "totalCost": "3028123"
       },
       "external": {
         "quoteRedemptionCurve(uint256)": "infinite",
-        "redeem(uint256,address,uint256,uint256[])": "infinite",
-        "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": "infinite",
-        "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": "infinite",
+        "redeem(uint256,address,uint256,uint256[],bytes32)": "infinite",
+        "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": "infinite",
+        "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": "infinite",
         "updateNormalizer(uint256,bool)": "infinite"
       },
       "internal": {
-        "_consumeAuthAndBurn(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_consumeAuthAndBurn(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_distributeRedemption(struct Redeemer.RedemptionExecution memory)": "infinite",
-        "_executeAuthorization(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_executeAuthorization(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_quoteRedemptionCurve(uint256)": "infinite",
-        "_redeem(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_redeem(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_updateNormalizer(uint256,bool)": "infinite"
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"CannotBurnAllStableIssued\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotWhitelisted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNormalizerValue\",\"type\":\"uint256\"}],\"name\":\"NormalizerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Redeemed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"quoteRedemptionCurve\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"}],\"name\":\"redeem\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"authData\",\"type\":\"bytes\"}],\"name\":\"redeemWithAuthorization\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"}],\"name\":\"redeemWithForfeit\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"updateNormalizer\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `Redeemer` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"returns\":{\"amounts\":\"Amount that would be obtained for each token in the `tokens` array\",\"tokens\":\"List of tokens that would be given\"}},\"redeem(uint256,address,uint256,uint256[])\":{\"details\":\"The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function\",\"params\":{\"deadline\":\"Timestamp before which the redemption should have occured\",\"minAmountOuts\":\"Minimum amount of each token given back in the redemption to obtain\",\"receiver\":\"Address which should be receiving the output tokens\"},\"returns\":{\"amounts\":\"Amount given for each token in the `tokens` array\",\"tokens\":\"List of tokens returned\"}},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)\":{\"details\":\"The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[])\":{\"details\":\"Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount\"},\"updateNormalizer(uint256,bool)\":{\"details\":\"This function may be called by trusted addresses: these could be for instance savings contract minting stablecoins when they notice a profit\"}},\"title\":\"Redeemer\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"notice\":\"Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\"},\"redeem(uint256,address,uint256,uint256[])\":{\"notice\":\"Redeems `amount` of stablecoins from the system\"},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)\":{\"notice\":\"Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[])\":{\"notice\":\"Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`.\"},\"updateNormalizer(uint256,bool)\":{\"notice\":\"Updates the normalizer variable by `amount`\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Redeemer.sol\":\"Redeemer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the\\n  /// signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x2ea4d5ebd3dd0e83071ebedb2c269f501f37033ddce9a1ee9ec40cfde0adfc7a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IEIP3009.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IEIP3009\\n/// @notice Interface for EIP-3009: Transfer With Authorization\\ninterface IEIP3009 {\\n  /// @notice Execute a transfer with a signed authorization (EOA signature)\\n  /// @dev SECURITY: anyone may submit this call (no `msg.sender` restriction). Integrators that\\n  /// pair the transfer with downstream logic (e.g. swap, deposit, redeem) MUST use\\n  /// `receiveWithAuthorization` instead: a mempool watcher can otherwise frontrun the original\\n  /// transaction with a raw `transferWithAuthorization`, burning the nonce so the original\\n  /// reverts while the funds still move - causing the post-transfer logic to be skipped.\\n  /// Use this primitive only for direct payouts to a passive recipient (`msg.sender != to`).\\n  /// @param from The address of the sender\\n  /// @param to The address of the recipient\\n  /// @param value The amount of tokens to transfer\\n  /// @param validAfter The timestamp after which the authorization is valid\\n  /// @param validBefore The timestamp before which the authorization is valid\\n  /// @param nonce The nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Execute a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev SECURITY: see the EOA overload - this primitive is frontrun-prone and must not be used\\n  /// when the transfer is bound to follow-on logic. Use `receiveWithAuthorization` in that case.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EOA signature)\\n  /// @dev The caller must be the payee (`to` address). This has an additional check to ensure\\n  /// that the payee's address matches the caller of this function to prevent front-running attacks.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev The caller must be the payee (`to` address)\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Attempt to cancel an authorization\\n  /// @dev Works only if the authorization is not yet used.\\n  /// EOA wallet signatures should be packed in the order of r, s, v.\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external;\\n\\n  /// @notice Cancel an authorization (EIP-1271 compatible)\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external;\\n\\n  /// @notice Returns the state of an authorization\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @return true if the nonce is used\\n  function authorizationState(address authorizer, bytes32 nonce) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe34cfb584a925054c2e3569c4401c619cd2b928a7b9da04537e71a9089edf55a\",\"license\":\"MIT\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Redeemer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IRedeemer } from \\\"contracts/interfaces/IRedeemer.sol\\\";\\nimport { IEIP3009 } from \\\"contracts/interfaces/external/IEIP3009.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\nimport { LibAuthorization } from \\\"../libraries/LibAuthorization.sol\\\";\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Redeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `Redeemer` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\\ncontract Redeemer is IRedeemer, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  event Redeemed(\\n    uint256 amount,\\n    address[] tokens,\\n    uint256[] amounts,\\n    address[] forfeitTokens,\\n    address indexed from,\\n    address indexed to\\n  );\\n  event NormalizerUpdated(uint256 newNormalizerValue);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev The `minAmountOuts` list must reflect the amount of `tokens` returned\\n  /// @dev In normal conditions, the amount of tokens outputted by this function should be the amount\\n  /// of collateral assets supported by the system, following their order in the `collateralList`.\\n  /// @dev If one collateral has its liquidity managed through strategies, then it's possible that this asset\\n  /// has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption\\n  /// process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral\\n  /// assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering\\n  /// of the token list will be as follows:\\n  /// `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`\\n  /// @dev The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained\\n  /// by calling the `quoteRedemptionCurve` function\\n  /// @dev Tokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the\\n  /// whitelist, otherwise this function reverts\\n  /// @dev No approval is needed before calling this function\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token\\n  /// even if it has enough immediately available to send the amount\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, authData);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev This function may be called by trusted addresses: these could be for instance savings contract\\n  /// minting stablecoins when they notice a profit\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256) {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && s.transmuterStorage().isTrusted[msg.sender] == 0) {\\n      revert NotTrusted();\\n    }\\n    return _updateNormalizer(amount, increase);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    (tokens, amounts,) = _quoteRedemptionCurve(amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Working set passed by reference between `_redeem` and its loop helper, so the call\\n  /// site stays under the EVM stack-depth limit when compiling without via-IR.\\n  struct RedemptionExecution {\\n    uint256 amount;\\n    address from;\\n    address to;\\n    address[] tokens;\\n    uint256[] amounts;\\n    uint256[] subCollateralsTracker;\\n    uint256[] minAmountOuts;\\n    address[] forfeitTokens;\\n  }\\n\\n  /// @notice Internal function of the `redeem` function in the `Redeemer` contract\\n  function _redeem(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    nonReentrant\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    if (s.transmuterStorage().isRedemptionLive == 0) revert Paused();\\n    if (block.timestamp > deadline) revert TooLate();\\n\\n    RedemptionExecution memory redemption;\\n    redemption.amount = amount;\\n    redemption.to = to;\\n    redemption.minAmountOuts = minAmountOuts;\\n    redemption.forfeitTokens = forfeitTokens;\\n\\n    (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);\\n    if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();\\n    _updateNormalizer(amount, false);\\n\\n    redemption.from = _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, authData);\\n\\n    _distributeRedemption(redemption);\\n    emit Redeemed(\\n      redemption.amount,\\n      redemption.tokens,\\n      redemption.amounts,\\n      redemption.forfeitTokens,\\n      redemption.from,\\n      redemption.to\\n    );\\n    return (redemption.tokens, redemption.amounts);\\n  }\\n\\n  /// @notice Releases each non-forfeited collateral output to `redemption.to`. Extracted from `_redeem`\\n  /// so the parent function stays within the EVM stack-depth limit.\\n  function _distributeRedemption(RedemptionExecution memory redemption) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 indexCollateral;\\n    uint256 amountsLength = redemption.amounts.length;\\n    for (uint256 i; i < amountsLength; ++i) {\\n      if (redemption.amounts[i] < redemption.minAmountOuts[i]) revert TooSmallAmountOut();\\n      // If a token is in the `forfeitTokens` list, then it is not sent as part of the redemption process\\n      if (redemption.amounts[i] > 0 && LibHelpers.checkList(redemption.tokens[i], redemption.forfeitTokens) < 0) {\\n        Collateral storage collatInfo = ts.collaterals[collateralListMem[indexCollateral]];\\n        if (collatInfo.onlyWhitelisted > 0 && !LibWhitelist.checkWhitelist(collatInfo.whitelistData, redemption.to)) {\\n          revert NotWhitelisted();\\n        }\\n        if (collatInfo.isManaged > 0) {\\n          LibManager.release(\\n            redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config\\n          );\\n        } else {\\n          IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);\\n        }\\n      }\\n      if (redemption.subCollateralsTracker[indexCollateral] - 1 <= i) ++indexCollateral;\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer (auth flow) or burns directly from\\n  /// `msg.sender`, and returns the address to attribute the `Redeemed` event to.\\n  function _consumeAuthAndBurn(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    ITokenP tokenP = s.transmuterStorage().tokenP;\\n    if (authData.length > 0) {\\n      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, authData);\\n      tokenP.burnSelf(amount, address(this));\\n    } else {\\n      from = msg.sender;\\n      tokenP.burnSelf(amount, msg.sender);\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer via EIP-3009 `receiveWithAuthorization`,\\n  /// using a derived nonce that binds the full redemption intent.\\n  /// @return from The authorizer address (`params.from`), to attribute the redeem event to\\n  function _executeAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));\\n    if (params.value != amount) revert InvalidSwap();\\n    bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(\\n      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, params.nonce\\n    );\\n    IEIP3009(address(s.transmuterStorage().tokenP)).receiveWithAuthorization(\\n      params.from,\\n      address(this),\\n      params.value,\\n      params.validAfter,\\n      params.validBefore,\\n      derivedNonce,\\n      params.signature\\n    );\\n    return params.from;\\n  }\\n\\n  /// @dev This function reverts if `stablecoinsIssued==0`, which is expected behavior as there is nothing to redeem\\n  /// anyway in this case, or if the `amountBurnt` is greater than `stablecoinsIssued`\\n  /// @dev Invariant: `penaltyFactor` is evaluated once at the entry-time `collatRatio` and applied uniformly to the\\n  /// full `amountBurnt`. The curve is not path-integrated, so a single redemption that traverses into a lower-penalty\\n  /// segment still pays the entry-time rate on every unit burned. Splitting the same redemption into smaller calls\\n  /// can yield a strictly better blended rate when the path crosses an ascending segment of the curve. This is a\\n  /// deliberate design choice consistent with penalizing early redemptions during under-collateralization; the gap\\n  /// between single-call and path-integrated pricing scales with the ascending-segment slope and should be\\n  /// considered when calibrating `xRedemptionCurve`/`yRedemptionCurve`.\\n  function _quoteRedemptionCurve(uint256 amountBurnt)\\n    internal\\n    view\\n    returns (address[] memory tokens, uint256[] memory balances, uint256[] memory subCollateralsTracker)\\n  {\\n    uint64 collatRatio;\\n    uint256 stablecoinsIssued;\\n    (collatRatio, stablecoinsIssued, tokens, balances, subCollateralsTracker) = LibGetters.getCollateralRatio();\\n    if (amountBurnt >= stablecoinsIssued) revert CannotBurnAllStableIssued();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    int64[] memory yRedemptionCurveMem = ts.yRedemptionCurve;\\n    uint64 penaltyFactor;\\n    // If the protocol is under-collateralized, a penalty factor is applied to the returned amount of each asset\\n    if (collatRatio < BASE_9) {\\n      uint64[] memory xRedemptionCurveMem = ts.xRedemptionCurve;\\n      penaltyFactor = uint64(LibHelpers.piecewiseLinear(collatRatio, xRedemptionCurveMem, yRedemptionCurveMem));\\n    }\\n\\n    for (uint256 i; i < balances.length; ++i) {\\n      // The amount given for each token in reserves does not depend on the price of the tokens in reserve:\\n      // it is a proportion of the balance for each token computed as the ratio between the stablecoins\\n      // burnt relative to the amount of stablecoins issued.\\n      // If the protocol is over-collateralized, the amount of each token given is inversely proportional\\n      // to the collateral ratio.\\n      balances[i] = collatRatio >= BASE_9\\n        ? (amountBurnt * balances[i] * (uint64(yRedemptionCurveMem[yRedemptionCurveMem.length - 1])))\\n          / (stablecoinsIssued * collatRatio)\\n        : (amountBurnt * balances[i] * penaltyFactor) / (stablecoinsIssued * BASE_9);\\n    }\\n  }\\n\\n  /// @notice Updates the `normalizer` variable used to track stablecoins issued from each asset and globally\\n  function _updateNormalizer(uint256 amount, bool increase) internal returns (uint256 newNormalizerValue) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    uint256 _normalizedStables = ts.normalizedStables;\\n    // In case of an increase, the update formula used is the simplified version of the formula below:\\n    /*\\n            _normalizer * (BASE_27 + BASE_27 * amount / stablecoinsIssued) / BASE_27\\n        = _normalizer + (_normalizer * BASE_27 * amount * (BASE_27 / (_normalizedStables * normalizer))) / BASE_27\\n             = _normalizer + BASE_27 * amount / _normalizedStables\\n        */\\n    if (increase) {\\n      newNormalizerValue = _normalizer + (amount * BASE_27) / _normalizedStables;\\n    } else {\\n      newNormalizerValue = _normalizer - (amount * BASE_27) / _normalizedStables;\\n    }\\n    // If the `normalizer` gets too small or too big, it must be renormalized to later avoid the propagation of\\n    // rounding errors, as well as overflows. In this case, the function has to iterate through all the\\n    // supported collateral assets\\n    if (newNormalizerValue <= BASE_18 || newNormalizerValue >= BASE_36) {\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 collateralListLength = collateralListMem.length;\\n      // For each asset, we store the actual amount of stablecoins issued based on the `newNormalizerValue`\\n      // (and not a normalized value)\\n      // We ensure to preserve the invariant `sum(collateralNewNormalizedStables) = normalizedStables`\\n      uint128 newNormalizedStables;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        uint128 newCollateralNormalizedStable = ((uint256(ts.collaterals[collateralListMem[i]].normalizedStables)\\n              * newNormalizerValue) / BASE_27)\\n        .toUint128();\\n        newNormalizedStables += newCollateralNormalizedStable;\\n        ts.collaterals[collateralListMem[i]].normalizedStables = uint216(newCollateralNormalizedStable);\\n      }\\n      ts.normalizedStables = newNormalizedStables;\\n      newNormalizerValue = BASE_27;\\n    }\\n    ts.normalizer = newNormalizerValue.toUint128();\\n    if (!increase && ts.normalizedStables == 0) revert CannotBurnAllStableIssued();\\n    emit NormalizerUpdated(newNormalizerValue);\\n  }\\n}\\n\",\"keccak256\":\"0x52467df54a2a68910287c51c0ee42d304de44a7ccacd22fff8426911835356f3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibAuthorization.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\n/// @title LibAuthorization\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Derives the EIP-3009 nonce that binds the Parallelizer's `*WithAuthorization` entry\\n/// points to their full swap/redeem intent (output `to`, slippage, deadline, ...), closing the\\n/// front-running gap left by vanilla `receiveWithAuthorization` which only commits to the token\\n/// transfer itself.\\n/// @dev Off-chain, the authorizer signs a standard EIP-3009 `ReceiveWithAuthorization` with\\n/// `nonce = compute*Nonce(...)`. The facet recomputes the same value from the call arguments and\\n/// forwards it to the token; tampering with any bound field makes the signature invalid. Replay\\n/// protection is provided by the token's own `authorizationStates` mapping; retries use a fresh\\n/// `userSalt`.\\nlibrary LibAuthorization {\\n  // keccak256(\\\"SwapExactInputWithAuthorization(address from,address tokenIn,address tokenOut,uint256 amountIn,uint256\\n  // amountOutMin,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x9be969f74c66b263054aa69cfac8412777a0dc17ab007f81682c6b156ba06d79;\\n\\n  // keccak256(\\\"SwapExactOutputWithAuthorization(address from,address tokenIn,address tokenOut,uint256\\n  // amountOut,uint256 amountInMax,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;\\n\\n  // keccak256(\\\"RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32\\n  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 userSalt)\\\")\\n  bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =\\n    0xcff34e096e1842f6f6ae4c0d0c6eefd4855c8bdc5bc64155d7c14b2dbeee661a;\\n\\n  function computeSwapExactInputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountIn,\\n        amountOutMin,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeSwapExactOutputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountOut,\\n        amountInMax,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeRedeemNonce(\\n    address from,\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        REDEEM_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        amount,\\n        receiver,\\n        deadline,\\n        keccak256(abi.encodePacked(minAmountOuts)),\\n        keccak256(abi.encodePacked(forfeitTokens)),\\n        userSalt\\n      )\\n    );\\n  }\\n}\\n\",\"keccak256\":\"0xe41991a0a564f4f6443aeffd6f1519ae3decc8a9e1e625f51ddf2168453ea4f2\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"CannotBurnAllStableIssued\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotWhitelisted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnexpectedRedemptionTokens\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNormalizerValue\",\"type\":\"uint256\"}],\"name\":\"NormalizerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Redeemed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"quoteRedemptionCurve\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"}],\"name\":\"redeem\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"authData\",\"type\":\"bytes\"}],\"name\":\"redeemWithAuthorization\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"}],\"name\":\"redeemWithForfeit\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"updateNormalizer\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `Redeemer` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"returns\":{\"amounts\":\"Amount that would be obtained for each token in the `tokens` array\",\"tokens\":\"List of tokens that would be given\"}},\"redeem(uint256,address,uint256,uint256[],bytes32)\":{\"details\":\"The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function\",\"params\":{\"deadline\":\"Timestamp before which the redemption should have occured\",\"expectedTokensHash\":\"`keccak256(abi.encodePacked(tokens))` over the output list the caller was quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\",\"minAmountOuts\":\"Minimum amount of each token given back in the redemption to obtain\",\"receiver\":\"Address which should be receiving the output tokens\"},\"returns\":{\"amounts\":\"Amount given for each token in the `tokens` array\",\"tokens\":\"List of tokens returned\"}},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)\":{\"details\":\"The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.`expectedTokensHash` matters most here: a signature stays executable for its whole validity window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)\":{\"details\":\"Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount\"},\"updateNormalizer(uint256,bool)\":{\"details\":\"This function may be called by trusted addresses: these could be for instance savings contract minting stablecoins when they notice a profit\"}},\"title\":\"Redeemer\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"notice\":\"Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\"},\"redeem(uint256,address,uint256,uint256[],bytes32)\":{\"notice\":\"Redeems `amount` of stablecoins from the system\"},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)\":{\"notice\":\"Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)\":{\"notice\":\"Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`.\"},\"updateNormalizer(uint256,bool)\":{\"notice\":\"Updates the normalizer variable by `amount`\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Redeemer.sol\":\"Redeemer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was\\n  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since\\n  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`\\n  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity\\n  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x3362bd4532915b6e2b26b2fdc967a89ea66de5ea5f669d7a621ee69d75c02273\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IEIP3009.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IEIP3009\\n/// @notice Interface for EIP-3009: Transfer With Authorization\\ninterface IEIP3009 {\\n  /// @notice Execute a transfer with a signed authorization (EOA signature)\\n  /// @dev SECURITY: anyone may submit this call (no `msg.sender` restriction). Integrators that\\n  /// pair the transfer with downstream logic (e.g. swap, deposit, redeem) MUST use\\n  /// `receiveWithAuthorization` instead: a mempool watcher can otherwise frontrun the original\\n  /// transaction with a raw `transferWithAuthorization`, burning the nonce so the original\\n  /// reverts while the funds still move - causing the post-transfer logic to be skipped.\\n  /// Use this primitive only for direct payouts to a passive recipient (`msg.sender != to`).\\n  /// @param from The address of the sender\\n  /// @param to The address of the recipient\\n  /// @param value The amount of tokens to transfer\\n  /// @param validAfter The timestamp after which the authorization is valid\\n  /// @param validBefore The timestamp before which the authorization is valid\\n  /// @param nonce The nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Execute a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev SECURITY: see the EOA overload - this primitive is frontrun-prone and must not be used\\n  /// when the transfer is bound to follow-on logic. Use `receiveWithAuthorization` in that case.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EOA signature)\\n  /// @dev The caller must be the payee (`to` address). This has an additional check to ensure\\n  /// that the payee's address matches the caller of this function to prevent front-running attacks.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev The caller must be the payee (`to` address)\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Attempt to cancel an authorization\\n  /// @dev Works only if the authorization is not yet used.\\n  /// EOA wallet signatures should be packed in the order of r, s, v.\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external;\\n\\n  /// @notice Cancel an authorization (EIP-1271 compatible)\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external;\\n\\n  /// @notice Returns the state of an authorization\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @return true if the nonce is used\\n  function authorizationState(address authorizer, bytes32 nonce) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe34cfb584a925054c2e3569c4401c619cd2b928a7b9da04537e71a9089edf55a\",\"license\":\"MIT\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Redeemer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IRedeemer } from \\\"contracts/interfaces/IRedeemer.sol\\\";\\nimport { IEIP3009 } from \\\"contracts/interfaces/external/IEIP3009.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\nimport { LibAuthorization } from \\\"../libraries/LibAuthorization.sol\\\";\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Redeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `Redeemer` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\\ncontract Redeemer is IRedeemer, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  event Redeemed(\\n    uint256 amount,\\n    address[] tokens,\\n    uint256[] amounts,\\n    address[] forfeitTokens,\\n    address indexed from,\\n    address indexed to\\n  );\\n  event NormalizerUpdated(uint256 newNormalizerValue);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev The `minAmountOuts` list must reflect the amount of `tokens` returned\\n  /// @dev In normal conditions, the amount of tokens outputted by this function should be the amount\\n  /// of collateral assets supported by the system, following their order in the `collateralList`.\\n  /// @dev If one collateral has its liquidity managed through strategies, then it's possible that this asset\\n  /// has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption\\n  /// process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral\\n  /// assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering\\n  /// of the token list will be as follows:\\n  /// `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`\\n  /// @dev The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained\\n  /// by calling the `quoteRedemptionCurve` function\\n  /// @dev Tokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the\\n  /// whitelist, otherwise this function reverts\\n  /// @dev No approval is needed before calling this function\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), expectedTokensHash, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token\\n  /// even if it has enough immediately available to send the amount\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev This function may be called by trusted addresses: these could be for instance savings contract\\n  /// minting stablecoins when they notice a profit\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256) {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && s.transmuterStorage().isTrusted[msg.sender] == 0) {\\n      revert NotTrusted();\\n    }\\n    return _updateNormalizer(amount, increase);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    (tokens, amounts,) = _quoteRedemptionCurve(amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Working set passed by reference between `_redeem` and its loop helper, so the call\\n  /// site stays under the EVM stack-depth limit when compiling without via-IR.\\n  struct RedemptionExecution {\\n    uint256 amount;\\n    address from;\\n    address to;\\n    address[] tokens;\\n    uint256[] amounts;\\n    uint256[] subCollateralsTracker;\\n    uint256[] minAmountOuts;\\n    address[] forfeitTokens;\\n  }\\n\\n  /// @notice Internal function of the `redeem` function in the `Redeemer` contract\\n  function _redeem(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    nonReentrant\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    if (s.transmuterStorage().isRedemptionLive == 0) revert Paused();\\n    if (block.timestamp > deadline) revert TooLate();\\n\\n    RedemptionExecution memory redemption;\\n    redemption.amount = amount;\\n    redemption.to = to;\\n    redemption.minAmountOuts = minAmountOuts;\\n    redemption.forfeitTokens = forfeitTokens;\\n\\n    (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);\\n    if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();\\n    // `minAmountOuts` is positional, so it only protects quantities. Binding the output list itself is what\\n    // ties each minimum to the token it was quoted against, across a collateral rotation\\n    if (keccak256(abi.encodePacked(redemption.tokens)) != expectedTokensHash) revert UnexpectedRedemptionTokens();\\n    _updateNormalizer(amount, false);\\n\\n    redemption.from =\\n      _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n\\n    _distributeRedemption(redemption);\\n    emit Redeemed(\\n      redemption.amount,\\n      redemption.tokens,\\n      redemption.amounts,\\n      redemption.forfeitTokens,\\n      redemption.from,\\n      redemption.to\\n    );\\n    return (redemption.tokens, redemption.amounts);\\n  }\\n\\n  /// @notice Releases each non-forfeited collateral output to `redemption.to`. Extracted from `_redeem`\\n  /// so the parent function stays within the EVM stack-depth limit.\\n  function _distributeRedemption(RedemptionExecution memory redemption) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 indexCollateral;\\n    uint256 amountsLength = redemption.amounts.length;\\n    for (uint256 i; i < amountsLength; ++i) {\\n      if (redemption.amounts[i] < redemption.minAmountOuts[i]) revert TooSmallAmountOut();\\n      // If a token is in the `forfeitTokens` list, then it is not sent as part of the redemption process\\n      if (redemption.amounts[i] > 0 && LibHelpers.checkList(redemption.tokens[i], redemption.forfeitTokens) < 0) {\\n        Collateral storage collatInfo = ts.collaterals[collateralListMem[indexCollateral]];\\n        if (collatInfo.onlyWhitelisted > 0 && !LibWhitelist.checkWhitelist(collatInfo.whitelistData, redemption.to)) {\\n          revert NotWhitelisted();\\n        }\\n        if (collatInfo.isManaged > 0) {\\n          LibManager.release(redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config);\\n        } else {\\n          IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);\\n        }\\n      }\\n      if (redemption.subCollateralsTracker[indexCollateral] - 1 <= i) ++indexCollateral;\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer (auth flow) or burns directly from\\n  /// `msg.sender`, and returns the address to attribute the `Redeemed` event to.\\n  function _consumeAuthAndBurn(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    ITokenP tokenP = s.transmuterStorage().tokenP;\\n    if (authData.length > 0) {\\n      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n      tokenP.burnSelf(amount, address(this));\\n    } else {\\n      from = msg.sender;\\n      tokenP.burnSelf(amount, msg.sender);\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer via EIP-3009 `receiveWithAuthorization`,\\n  /// using a derived nonce that binds the full redemption intent.\\n  /// @return from The authorizer address (`params.from`), to attribute the redeem event to\\n  function _executeAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));\\n    if (params.value != amount) revert InvalidSwap();\\n    bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(\\n      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, params.nonce\\n    );\\n    IEIP3009(address(s.transmuterStorage().tokenP))\\n      .receiveWithAuthorization(\\n        params.from, address(this), params.value, params.validAfter, params.validBefore, derivedNonce, params.signature\\n      );\\n    return params.from;\\n  }\\n\\n  /// @dev This function reverts if `stablecoinsIssued==0`, which is expected behavior as there is nothing to redeem\\n  /// anyway in this case, or if the `amountBurnt` is greater than `stablecoinsIssued`\\n  /// @dev Invariant: `penaltyFactor` is evaluated once at the entry-time `collatRatio` and applied uniformly to the\\n  /// full `amountBurnt`. The curve is not path-integrated, so a single redemption that traverses into a lower-penalty\\n  /// segment still pays the entry-time rate on every unit burned. Splitting the same redemption into smaller calls\\n  /// can yield a strictly better blended rate when the path crosses an ascending segment of the curve. This is a\\n  /// deliberate design choice consistent with penalizing early redemptions during under-collateralization; the gap\\n  /// between single-call and path-integrated pricing scales with the ascending-segment slope and should be\\n  /// considered when calibrating `xRedemptionCurve`/`yRedemptionCurve`.\\n  function _quoteRedemptionCurve(uint256 amountBurnt)\\n    internal\\n    view\\n    returns (address[] memory tokens, uint256[] memory balances, uint256[] memory subCollateralsTracker)\\n  {\\n    uint64 collatRatio;\\n    uint256 stablecoinsIssued;\\n    (collatRatio, stablecoinsIssued, tokens, balances, subCollateralsTracker) = LibGetters.getCollateralRatio();\\n    if (amountBurnt >= stablecoinsIssued) revert CannotBurnAllStableIssued();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    int64[] memory yRedemptionCurveMem = ts.yRedemptionCurve;\\n    uint64 penaltyFactor;\\n    // If the protocol is under-collateralized, a penalty factor is applied to the returned amount of each asset\\n    if (collatRatio < BASE_9) {\\n      uint64[] memory xRedemptionCurveMem = ts.xRedemptionCurve;\\n      penaltyFactor = uint64(LibHelpers.piecewiseLinear(collatRatio, xRedemptionCurveMem, yRedemptionCurveMem));\\n    }\\n\\n    for (uint256 i; i < balances.length; ++i) {\\n      // The amount given for each token in reserves does not depend on the price of the tokens in reserve:\\n      // it is a proportion of the balance for each token computed as the ratio between the stablecoins\\n      // burnt relative to the amount of stablecoins issued.\\n      // If the protocol is over-collateralized, the amount of each token given is inversely proportional\\n      // to the collateral ratio.\\n      balances[i] = collatRatio >= BASE_9\\n        ? (amountBurnt * balances[i] * (uint64(yRedemptionCurveMem[yRedemptionCurveMem.length - 1])))\\n          / (stablecoinsIssued * collatRatio)\\n        : (amountBurnt * balances[i] * penaltyFactor) / (stablecoinsIssued * BASE_9);\\n    }\\n  }\\n\\n  /// @notice Updates the `normalizer` variable used to track stablecoins issued from each asset and globally\\n  function _updateNormalizer(uint256 amount, bool increase) internal returns (uint256 newNormalizerValue) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    uint256 _normalizedStables = ts.normalizedStables;\\n    // In case of an increase, the update formula used is the simplified version of the formula below:\\n    /*\\n            _normalizer * (BASE_27 + BASE_27 * amount / stablecoinsIssued) / BASE_27\\n        = _normalizer + (_normalizer * BASE_27 * amount * (BASE_27 / (_normalizedStables * normalizer))) / BASE_27\\n             = _normalizer + BASE_27 * amount / _normalizedStables\\n        */\\n    if (increase) {\\n      newNormalizerValue = _normalizer + (amount * BASE_27) / _normalizedStables;\\n    } else {\\n      newNormalizerValue = _normalizer - (amount * BASE_27) / _normalizedStables;\\n    }\\n    // If the `normalizer` gets too small or too big, it must be renormalized to later avoid the propagation of\\n    // rounding errors, as well as overflows. In this case, the function has to iterate through all the\\n    // supported collateral assets\\n    if (newNormalizerValue <= BASE_18 || newNormalizerValue >= BASE_36) {\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 collateralListLength = collateralListMem.length;\\n      // For each asset, we store the actual amount of stablecoins issued based on the `newNormalizerValue`\\n      // (and not a normalized value)\\n      // We ensure to preserve the invariant `sum(collateralNewNormalizedStables) = normalizedStables`\\n      uint128 newNormalizedStables;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        uint128 newCollateralNormalizedStable = ((uint256(ts.collaterals[collateralListMem[i]].normalizedStables)\\n              * newNormalizerValue) / BASE_27)\\n        .toUint128();\\n        newNormalizedStables += newCollateralNormalizedStable;\\n        ts.collaterals[collateralListMem[i]].normalizedStables = uint216(newCollateralNormalizedStable);\\n      }\\n      ts.normalizedStables = newNormalizedStables;\\n      newNormalizerValue = BASE_27;\\n    }\\n    ts.normalizer = newNormalizerValue.toUint128();\\n    if (!increase && ts.normalizedStables == 0) revert CannotBurnAllStableIssued();\\n    emit NormalizerUpdated(newNormalizerValue);\\n  }\\n}\\n\",\"keccak256\":\"0x1a67602de708b202cbfb4311b65c8e28294c043d059c53c66dcd9c7b1512d3c0\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibAuthorization.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\n/// @title LibAuthorization\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Derives the EIP-3009 nonce that binds the Parallelizer's `*WithAuthorization` entry\\n/// points to their full swap/redeem intent (output `to`, slippage, deadline, ...), closing the\\n/// front-running gap left by vanilla `receiveWithAuthorization` which only commits to the token\\n/// transfer itself.\\n/// @dev Off-chain, the authorizer signs a standard EIP-3009 `ReceiveWithAuthorization` with\\n/// `nonce = compute*Nonce(...)`. The facet recomputes the same value from the call arguments and\\n/// forwards it to the token; tampering with any bound field makes the signature invalid. Replay\\n/// protection is provided by the token's own `authorizationStates` mapping; retries use a fresh\\n/// `userSalt`.\\nlibrary LibAuthorization {\\n  // keccak256(\\\"SwapExactInputWithAuthorization(address from,address tokenIn,address tokenOut,uint256 amountIn,uint256\\n  // amountOutMin,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x9be969f74c66b263054aa69cfac8412777a0dc17ab007f81682c6b156ba06d79;\\n\\n  // keccak256(\\\"SwapExactOutputWithAuthorization(address from,address tokenIn,address tokenOut,uint256\\n  // amountOut,uint256 amountInMax,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;\\n\\n  // keccak256(\\\"RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32\\n  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 expectedTokensHash,bytes32 userSalt)\\\")\\n  bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =\\n    0xb6577f08e668b53303325a19233e8315142d69bedb6d7e1d8d0e9af2473486d4;\\n\\n  function computeSwapExactInputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountIn,\\n        amountOutMin,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeSwapExactOutputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountOut,\\n        amountInMax,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the redemption output list the\\n  /// authorizer was quoted, binding token identity and ordering rather than raw amounts alone\\n  function computeRedeemNonce(\\n    address from,\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        REDEEM_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        amount,\\n        receiver,\\n        deadline,\\n        keccak256(abi.encodePacked(minAmountOuts)),\\n        keccak256(abi.encodePacked(forfeitTokens)),\\n        expectedTokensHash,\\n        userSalt\\n      )\\n    );\\n  }\\n}\\n\",\"keccak256\":\"0x195b02224ec034756820857b7f88acc6ace194d00a68a9a6f0bcb8adf38963c8\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -407,13 +428,13 @@
       "quoteRedemptionCurve(uint256)": {
         "notice": "Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block"
       },
-      "redeem(uint256,address,uint256,uint256[])": {
+      "redeem(uint256,address,uint256,uint256[],bytes32)": {
         "notice": "Redeems `amount` of stablecoins from the system"
       },
-      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": {
+      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": {
         "notice": "Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer."
       },
-      "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": {
+      "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": {
         "notice": "Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`."
       },
       "updateNormalizer(uint256,bool)": {
@@ -424,13 +445,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0x683933b72b7f81a3fee33b7107d5d1a98a3ff82338354d4cc41508b886ad3de9",
-    "nonce": "0xb2",
+    "hash": "0x49ddf768d3297b81bf439d205686ed92faa5ba08e0f87b9fbaf5f998b7d985d5",
+    "nonce": "0xcd",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
     "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-    "blockNumber": "0x2eb0651",
-    "transactionIndex": "0x33"
+    "blockNumber": "0x31e6d76",
+    "transactionIndex": "0x3b"
   }
 }
\ No newline at end of file
diff --git a/deployments/base/RewardHandler.json b/deployments/base/RewardHandler.json
index 033ee36..f92cb33 100644
--- a/deployments/base/RewardHandler.json
+++ b/deployments/base/RewardHandler.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x2c85d2e8ecfabc0710ce87ca2c5278ae26733a85",
+  "address": "0x6cd1948f6ae0b49f7778167ffa94d7d148c8a307",
   "abi": [
     {
       "inputs": [],
@@ -18,12 +18,12 @@
     },
     {
       "inputs": [],
-      "name": "OdosSwapFailed",
+      "name": "ReentrantCall",
       "type": "error"
     },
     {
       "inputs": [],
-      "name": "ReentrantCall",
+      "name": "RewardSwapFailed",
       "type": "error"
     },
     {
@@ -42,6 +42,11 @@
       "name": "TooSmallAmountOut",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -88,8 +93,8 @@
   ],
   "contractName": "RewardHandler",
   "sourceName": "contracts/parallelizer/facets/RewardHandler.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -108,7 +113,7 @@
     "kind": "dev",
     "methods": {
       "sellRewards(uint256,bytes)": {
-        "details": "It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to Odos router for the token to be swapped"
+        "details": "It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to the configured `swapRouter` for the token to be swapped"
       }
     },
     "title": "RewardHandler",
@@ -117,9 +122,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "800000",
-        "executionCost": "829",
-        "totalCost": "800829"
+        "codeDepositCost": "810200",
+        "executionCost": "842",
+        "totalCost": "811042"
       },
       "external": {
         "sellRewards(uint256,bytes)": "infinite"
@@ -129,7 +134,7 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokens\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OdosSwapFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenObtained\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"balanceUpdate\",\"type\":\"uint256\"}],\"name\":\"RewardsSoldFor\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"sellRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `RewardHandler` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"details\":\"It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to Odos router for the token to be swapped\"}},\"title\":\"RewardHandler\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"notice\":\"IRewardHandler\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/RewardHandler.sol\":\"RewardHandler\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/RewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { IRewardHandler } from \\\"contracts/interfaces/IRewardHandler.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title RewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `RewardHandler` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\\ncontract RewardHandler is IRewardHandler, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n\\n  event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);\\n\\n  /// @notice IRewardHandler\\n  /// @dev It is impossible to sell a token that is a collateral through this function\\n  /// @dev Trusted sellers and governance only may call this function\\n  /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval\\n  /// transaction to Odos router for the token to be swapped\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    address[] memory list = ts.collateralList;\\n    uint256 listLength = list.length;\\n    uint256[] memory balances = new uint256[](listLength);\\n    // Getting the balances of all collateral assets of the protocol to see if those do not decrease during\\n    // the swap: this is the only way to check that collateral assets have not been sold\\n    // Not checking the `subCollaterals` here as swaps should try to increase the balance of one collateral\\n    for (uint256 i; i < listLength; ++i) {\\n      balances[i] = IERC20(list[i]).balanceOf(address(this));\\n    }\\n    uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));\\n    //solhint-disable-next-line\\n    (bool success, bytes memory result) = ODOS_ROUTER.call(payload);\\n    if (!success) _revertBytes(result);\\n    if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();\\n    bool hasIncreased;\\n    address collateral;\\n    for (uint256 i; i < listLength; ++i) {\\n      uint256 newBalance = IERC20(list[i]).balanceOf(address(this));\\n      if (newBalance < balances[i]) {\\n        revert InvalidSwap();\\n      } else if (newBalance > balances[i]) {\\n        hasIncreased = true;\\n        collateral = list[i];\\n        amountOut = newBalance - balances[i];\\n        if (amountOut < minAmountOut) revert TooSmallAmountOut();\\n        emit RewardsSoldFor(collateral, amountOut);\\n      }\\n    }\\n    if (!hasIncreased) revert InvalidSwap();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      IERC20(collateral).safeTransfer(LibManager.transferRecipient(collatInfo.managerData.config), amountOut);\\n      LibManager.invest(amountOut, collatInfo.managerData.config);\\n    }\\n  }\\n\\n  /// @notice Processes odos revert messages\\n  function _revertBytes(bytes memory errMsg) private pure {\\n    if (errMsg.length > 0) {\\n      //solhint-disable-next-line\\n      assembly (\\\"memory-safe\\\") {\\n        revert(add(32, errMsg), mload(errMsg))\\n      }\\n    }\\n    revert OdosSwapFailed();\\n  }\\n}\\n\",\"keccak256\":\"0xf01917011b3966f1783fa024ce6c56b5294ef0f65531bdc3f2e068649cd45038\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokens\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RewardSwapFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenObtained\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"balanceUpdate\",\"type\":\"uint256\"}],\"name\":\"RewardsSoldFor\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"sellRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `RewardHandler` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"details\":\"It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to the configured `swapRouter` for the token to be swapped\"}},\"title\":\"RewardHandler\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"notice\":\"IRewardHandler\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/RewardHandler.sol\":\"RewardHandler\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a call to the configured swap router\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to the swap router\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xb3604f35c5bb44791020588e00774299a6a4adae17d62d1e53cd8be86da6b709\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/RewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { IRewardHandler } from \\\"contracts/interfaces/IRewardHandler.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title RewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `RewardHandler` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\\ncontract RewardHandler is IRewardHandler, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n\\n  event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);\\n\\n  /// @notice IRewardHandler\\n  /// @dev It is impossible to sell a token that is a collateral through this function\\n  /// @dev Trusted sellers and governance only may call this function\\n  /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval\\n  /// transaction to the configured `swapRouter` for the token to be swapped\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    address[] memory list = ts.collateralList;\\n    uint256 listLength = list.length;\\n    uint256[] memory balances = new uint256[](listLength);\\n    // Getting the balances of all collateral assets of the protocol to see if those do not decrease during\\n    // the swap: this is the only way to check that collateral assets have not been sold\\n    // Not checking the `subCollaterals` here as swaps should try to increase the balance of one collateral\\n    for (uint256 i; i < listLength; ++i) {\\n      balances[i] = IERC20(list[i]).balanceOf(address(this));\\n    }\\n    uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));\\n    address swapRouter = ts.swapRouter;\\n    if (swapRouter == address(0)) revert ZeroAddress();\\n    //solhint-disable-next-line\\n    (bool success, bytes memory result) = swapRouter.call(payload);\\n    if (!success) _revertBytes(result);\\n    if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();\\n    bool hasIncreased;\\n    address collateral;\\n    for (uint256 i; i < listLength; ++i) {\\n      uint256 newBalance = IERC20(list[i]).balanceOf(address(this));\\n      if (newBalance < balances[i]) {\\n        revert InvalidSwap();\\n      } else if (newBalance > balances[i]) {\\n        hasIncreased = true;\\n        collateral = list[i];\\n        amountOut = newBalance - balances[i];\\n        if (amountOut < minAmountOut) revert TooSmallAmountOut();\\n        emit RewardsSoldFor(collateral, amountOut);\\n      }\\n    }\\n    if (!hasIncreased) revert InvalidSwap();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      IERC20(collateral).safeTransfer(LibManager.transferRecipient(collatInfo.managerData.config), amountOut);\\n      LibManager.invest(amountOut, collatInfo.managerData.config);\\n    }\\n  }\\n\\n  /// @notice Processes the router's revert messages\\n  function _revertBytes(bytes memory errMsg) private pure {\\n    if (errMsg.length > 0) {\\n      //solhint-disable-next-line\\n      assembly (\\\"memory-safe\\\") {\\n        revert(add(32, errMsg), mload(errMsg))\\n      }\\n    }\\n    revert RewardSwapFailed();\\n  }\\n}\\n\",\"keccak256\":\"0xa4e2fdeaaa43d78dfe1a81f458108856ebc92f27a7194e6293ac3c5084325beb\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -145,13 +150,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0x83004e52a41495b5242d10c39e0dc39a9e609219ba291c840af830a4a8bee795",
-    "nonce": "0xb3",
+    "hash": "0x2838918510f6712c049c3196137284bc58b3ea44465364495cb8cbc69aced270",
+    "nonce": "0xce",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
     "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-    "blockNumber": "0x2eb0651",
-    "transactionIndex": "0x58"
+    "blockNumber": "0x31e6d76",
+    "transactionIndex": "0x63"
   }
 }
\ No newline at end of file
diff --git a/deployments/base/SettersGovernor.json b/deployments/base/SettersGovernor.json
index 6d9354d..cb78032 100644
--- a/deployments/base/SettersGovernor.json
+++ b/deployments/base/SettersGovernor.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x153bf462a553c2e1d45d9f5cad4e70e9a362caee",
+  "address": "0x028c3e3a0984c441c5205cfd0c39a6cf244ee696",
   "abi": [
     {
       "inputs": [],
@@ -57,6 +57,11 @@
       "name": "InvalidParams",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "InvalidPayee",
+      "type": "error"
+    },
     {
       "inputs": [],
       "name": "InvalidRate",
@@ -135,6 +140,11 @@
       "name": "SafeERC20FailedOperation",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
     {
       "inputs": [],
       "name": "ZeroAmount",
@@ -285,6 +295,31 @@
       "name": "OracleSet",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "collateral",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "previousTarget",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "newTarget",
+          "type": "uint256"
+        }
+      ],
+      "name": "OracleTargetUpdated",
+      "type": "event"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -405,6 +440,19 @@
       "name": "SurplusBufferRatioUpdated",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "swapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "SwapRouterUpdated",
+      "type": "event"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -601,6 +649,19 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "swapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "setSwapRouter",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -712,8 +773,8 @@
   ],
   "contractName": "SettersGovernor",
   "sourceName": "contracts/parallelizer/facets/SettersGovernor.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "0x608060405234801561000f575f5ffd5b50600436106100f0575f3560e01c80637c0343a111610093578063c1cdee7e11610063578063c1cdee7e146101c7578063c9580804146101da578063dd94be04146101ed578063f0d2d5a814610200575f5ffd5b80637c0343a11461017b57806383eae17b1461018e57806387c8ab7a146101a1578063b13b0847146101b4575f5ffd5b80634591f148116100ce5780634591f1481461012f5780634d2b3e1414610142578063561c14c4146101555780635c3eebda14610168575f5ffd5b80631b0c7182146100f45780631cb44dfc14610109578063412736571461011c575b5f5ffd5b6101076101023660046132c6565b610213565b005b610107610117366004613324565b610251565b61010761012a366004613324565b6102c3565b61010761013d36600461335c565b6102f5565b6101076101503660046133b6565b61032c565b6101076101633660046134d3565b610360565b6101076101763660046134fa565b610392565b610107610189366004613554565b610501565b61010761019c366004613580565b610534565b6101076101af3660046135aa565b610567565b6101076101c23660046135e8565b61065c565b6101076101d5366004613649565b61068f565b6101076101e8366004613324565b6106c3565b6101076101fb3660046136f6565b6106f5565b61010761020e366004613324565b610729565b61021e335f3661075b565b6102415760405162d1953b60e31b81523360048201526024015b60405180910390fd5b61024c838383610894565b505050565b335f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7c602052604081205490036102b7576040517fc22a648e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6102c0816109e5565b50565b6102ce335f3661075b565b6102ec5760405162d1953b60e31b8152336004820152602401610238565b6102c081610c98565b610300335f3661075b565b61031e5760405162d1953b60e31b8152336004820152602401610238565b6103288282610d40565b5050565b610337335f3661075b565b6103555760405162d1953b60e31b8152336004820152602401610238565b61024c8383836110e9565b61036b335f3661075b565b6103895760405162d1953b60e31b8152336004820152602401610238565b6102c08161129b565b61039d335f3661075b565b6103bb5760405162d1953b60e31b8152336004820152602401610238565b6001600160a01b0384165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a60205260409020805460ff161561049957610494848484846007016001018054610413906137ca565b80601f016020809104026020016040519081016040528092919081815260200182805461043f906137ca565b801561048a5780601f106104615761010080835404028352916020019161048a565b820191905f5260205f20905b81548152906001019060200180831161046d57829003601f168201915b5050505050611369565b6104ad565b6104ad6001600160a01b038516848461142b565b826001600160a01b0316846001600160a01b03167ffff3b3844276f57024e0b42afec1a37f75db36511e43819a4f2a63ab7862b648846040516104f291815260200190565b60405180910390a35050505050565b61050c335f3661075b565b61052a5760405162d1953b60e31b8152336004820152602401610238565b610328828261148a565b61053f335f3661075b565b61055d5760405162d1953b60e31b8152336004820152602401610238565b610328828261157b565b610572335f3661075b565b6105905760405162d1953b60e31b8152336004820152602401610238565b604051636eb1769f60e11b81523060048201526001600160a01b0383811660248301525f919085169063dd62ed3e90604401602060405180830381865afa1580156105dd573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106019190613802565b90508181101561062f5761062a83610619838561382d565b6001600160a01b038716919061163b565b610656565b818111156106565761065683610645848461382d565b6001600160a01b03871691906116c2565b50505050565b610667335f3661075b565b6106855760405162d1953b60e31b8152336004820152602401610238565b6103288282611795565b61069a335f3661075b565b6106b85760405162d1953b60e31b8152336004820152602401610238565b61024c8383836118c3565b6106ce335f3661075b565b6106ec5760405162d1953b60e31b8152336004820152602401610238565b6102c081611b87565b610700335f3661075b565b61071e5760405162d1953b60e31b8152336004820152602401610238565b61024c838383611c5e565b610734335f3661075b565b6107525760405162d1953b60e31b8152336004820152602401610238565b6102c081611f3e565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d545f906001600160a01b031681806107ab83883061079d6004868b8d613840565b6107a691613867565b612087565b91509150816108855763ffffffff81161561087a575f5160206142df5f395f51905f52805460ff60b01b19167601000000000000000000000000000000000000000000001781556040517f94c7d7ee0000000000000000000000000000000000000000000000000000000081526001600160a01b038516906394c7d7ee9061083b908b908b908b906004016138cd565b5f604051808303815f87803b158015610852575f5ffd5b505af1158015610864573d5f5f3e3d5ffd5b5050825460ff60b01b1916909255506108859050565b5f935050505061088d565b600193505050505b9392505050565b60018260ff1611156108d2576040517fd5fb0c3c00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b0383165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a6020526040812080549091630100000090910460ff16900361093657604051630dcfc57f60e21b815260040160405180910390fd5b8260ff166001036109605761094b823061214a565b506006810161095a8382613956565b5061097f565b60408051602081019091525f8152600682019061097d9082613956565b505b805464ff00000000191664010000000060ff8516021781556040516001600160a01b038516907f191460c727cbee9e6c46ead7c01c84a1fe8f0b99186af38917ac57de17e6ba99906109d79060068501908790613a11565b60405180910390a250505050565b6001600160a01b0381165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a60205260408120545f5160206142df5f395f51905f5291630100000090910460ff169003610a5557604051630dcfc57f60e21b815260040160405180910390fd5b5f5f5f5f5f610b11866005015f896001600160a01b03166001600160a01b031681526020019081526020015f206005018054610a90906137ca565b80601f0160208091040260200160405190810160405280929190818152602001828054610abc906137ca565b8015610b075780601f10610ade57610100808354040283529160200191610b07565b820191905f5260205f20905b815481529060010190602001808311610aea57829003601f168201915b50505050506122bd565b9398509196509450925090506008846009811115610b3157610b31613aa0565b14610b4f57604051635516a7db60e11b815260040160405180910390fd5b5f610b6386670de0b6b3a7640000866122ea565b90505f83806020019051810190610b7a9190613802565b90508082111580610bbd5750610b9f66b1a2bc2ec50000670de0b6b3a7640000613ab4565b610ba99082613ac7565b610bbb670de0b6b3a764000084613ac7565b115b15610bdb57604051635516a7db60e11b815260040160405180910390fd5b86868684604051602001610bf191815260200190565b60408051601f1981840301815290829052610c13949392918890602001613b20565b60408051601f198184030181529181526001600160a01b038b165f9081526005808c016020529190200190610c489082613956565b5060408051828152602081018490526001600160a01b038b16917f8d1ba64ec7e754c448f8fc563a78c865de6719a0ed302eb3307b92b4ddaf27d4910160405180910390a2505050505050505050565b6001600160a01b038116610cd8576040517fd92e233d00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c8480546001600160a01b0319166001600160a01b0383169081179091556040517f36db479a3b4d3672bd6f5fca4484283f60b5ac70647b1ceec13ecbb1d030a2df905f90a250565b6001600160a01b0382165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a6020526040812080545f5160206142df5f395f51905f5292630100000090910460ff169003610db157604051630dcfc57f60e21b815260040160405180910390fd5b80546501000000000090046001600160d81b031615610dfc576040517fba80a36400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff168015801590610e0d5750835b15610ecd575f610ea9836007016001018054610e28906137ca565b80601f0160208091040260200160405190810160405280929190818152602001828054610e54906137ca565b8015610e9f5780601f10610e7657610100808354040283529160200191610e9f565b820191905f5260205f20905b815481529060010190602001808311610e8257829003601f168201915b50505050506126e8565b9150508015610ecb576040516309e7761b60e41b815260040160405180910390fd5b505b6001600160a01b0385165f908152600584016020526040812081815590610ef760018301826130da565b610f04600283015f6130da565b610f11600383015f6130da565b610f1e600483015f6130da565b610f2b600583015f6130fc565b610f38600683015f6130fc565b600782015f610f478282613133565b610f54600183015f6130fc565b5050600982015f905550505f83600201805480602002602001604051908101604052809291908181526020018280548015610fb657602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610f98575b505083519394505f925050505b610fce60018361382d565b81101561107857876001600160a01b0316838281518110610ff157610ff1613b72565b60200260200101516001600160a01b031603611070578261101360018461382d565b8151811061102357611023613b72565b602002602001015186600201828154811061104057611040613b72565b905f5260205f20015f6101000a8154816001600160a01b0302191690836001600160a01b03160217905550611078565b600101610fc3565b508460020180548061108c5761108c613b86565b5f8281526020812082015f1990810180546001600160a01b03191690559091019091556040516001600160a01b038916917f10d8ed8cba916885e339cb21deefb3842b3f417eac81a7f34b2978b4ecc2040f91a250505050505050565b6001600160a01b0383165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a6020526040812080549091630100000090910460ff16900361114d57604051630dcfc57f60e21b815260040160405180910390fd5b805460ff16801580159061115e5750835b1561119d575f611179836007016001018054610e28906137ca565b915050801561119b576040516309e7761b60e41b815260040160405180910390fd5b505b6020830151511561121557846001600160a01b0316835f01515f815181106111c7576111c7613b72565b60200260200101516001600160a01b0316146111f657604051635435b28960e11b815260040160405180910390fd5b6112038360200151612797565b5050815460ff1916600117825561121e565b815460ff191682555b825180518491600785019161123a91839160209091019061314e565b506020820151600182019061124f9082613956565b50905050846001600160a01b03167f174af9868421277c39ff3056a92d06c83d74df4c7f64258add97ea2bdc022d818460405161128c9190613b9a565b60405180910390a25050505050565b633b9aca0067ffffffffffffffff821610156112e3576040517fd252903400000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7f805467ffffffffffffffff831667ffffffffffffffff19909116811790915560408051918252515f5160206142df5f395f51905f52917fd10846add063582adb6e1c2f4392fd53c43643197b1cbfff38b5aff8d656d17c919081900360200190a15050565b5f5f61137483612797565b90925090505f82801561138957611389613aa0565b0361142357808060200190518101906113a29190613c09565b6040517f8bfb07c90000000000000000000000000000000000000000000000000000000081526001600160a01b0388811660048301528781166024830152604482018790529190911690638bfb07c9906064015f604051808303815f87803b15801561140c575f5ffd5b505af115801561141e573d5f5f3e3d5ffd5b505050505b505050505050565b6040516001600160a01b0383811660248301526044820183905261024c91859182169063a9059cbb906064015b604051602081830303815290604052915060e01b6020820180516001600160e01b0383818316178352505050506127b8565b5f5160206142df5f395f51905f525f808360018111156114ac576114ac613aa0565b036114f9576001600160a01b0384165f9081526006830160205260409020546114d690600161382d565b6001600160a01b0385165f9081526006840160205260409020819055905061153d565b6001600160a01b0384165f90815260078301602052604090205461151e90600161382d565b6001600160a01b0385165f908152600784016020526040902081905590505b836001600160a01b03167ff659c9a30c41638c696d64b6e8cc1ee8fff543e973ffc1e9e2d794225ae0178a82600114856040516109d7929190613c24565b633b9aca008111156115b9576040517f6a43f8d100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6001600160a01b0382165f8181527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7e602090815260409182902084905590518381525f5160206142df5f395f51905f5292917fb3a17cf8bbe3a4348266beede3a365af15dd59203021a6c1121d00ca2d5019f7910160405180910390a2505050565b604051636eb1769f60e11b81523060048201526001600160a01b0383811660248301525f919085169063dd62ed3e90604401602060405180830381865afa158015611688573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906116ac9190613802565b905061065684846116bd8585613ab4565b61283d565b604051636eb1769f60e11b81523060048201526001600160a01b0383811660248301525f919085169063dd62ed3e90604401602060405180830381865afa15801561170f573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906117339190613802565b905081811015611788576040517fe570110f0000000000000000000000000000000000000000000000000000000081526001600160a01b03841660048201526024810182905260448101839052606401610238565b610656848484840361283d565b6001600160a01b0382165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a6020526040812080549091630100000090910460ff1690036117f957604051630dcfc57f60e21b815260040160405180910390fd5b5f8280602001905181019061180e9190613ca5565b9450505050505f5f8280602001905181019061182a9190613d54565b91509150806001600160801b0316826001600160801b0316111561186157604051635435b28960e11b815260040160405180910390fd5b61186a856128e5565b50600584016118798682613956565b50856001600160a01b03167fba11329c0b0f98b91c254755aa8d698feac3b46fab65b65fe5ab7570de2ff928866040516118b39190613d81565b60405180910390a2505050505050565b6001600160a01b0383165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a6020526040812080545f5160206142df5f395f51905f5292630100000090910460ff16900361193457604051630dcfc57f60e21b815260040160405180910390fd5b60018201545f90611987906001600160801b03700100000000000000000000000000000000909104811690611978906b033b2e3c9fd0803ce8000000908916613ac7565b6119829190613da7565b6129e8565b90508315611aad5781546119b7906001600160801b038316906501000000000090046001600160d81b0316613dc6565b82546001600160d81b0391909116650100000000000264ffffffffff90911617825560018301546119f29082906001600160801b0316613de5565b6001840180546fffffffffffffffffffffffffffffffff19166001600160801b0392831617908190556009840154845490926b033b2e3c9fd0803ce800000092611a6692700100000000000000000000000000000000909104909116906501000000000090046001600160d81b0316613ac7565b611a709190613da7565b1115611aa8576040517f4d1dd38900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b611b3c565b8154611ad5906001600160801b038316906501000000000090046001600160d81b0316613e04565b82546001600160d81b0391909116650100000000000264ffffffffff9091161782556001830154611b109082906001600160801b0316613e23565b6001840180546fffffffffffffffffffffffffffffffff19166001600160801b03929092169190911790555b604080516001600160801b038716815285151560208201526001600160a01b038816917f2347e219eb6e83e63152eb917ddb1df919c0f9208fa91dda0bd14822c6be1d0791016118b3565b806001600160a01b03163b5f03611bca576040517fa98154e200000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d80546001600160a01b031981166001600160a01b038481169182179093556040517fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b939092169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a3505050565b82511580611c6d5750600a8351115b15611ca4576040517f1df89e8b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8151835114611cdf576040517fa24a13a600000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5160206142df5f395f51905f5281611df65780546040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201525f916001600160a01b0316906370a0823190602401602060405180830381865afa158015611d50573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611d749190613802565b90505f81118015611d885750600d82015415155b15611df457611df18183600d01805480602002602001604051908101604052809291908181526020018280548015611de757602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311611dc9575b5050505050612a38565b50505b505b5f5b600d820154811015611e4b575f82600e015f84600d018481548110611e1f57611e1f613b72565b5f9182526020808320909101546001600160a01b03168352820192909252604001902055600101611df8565b611e58600d83015f613133565b505f805b8551821015611f2f575f5b82811015611edb57868381518110611e8157611e81613b72565b60200260200101516001600160a01b0316878281518110611ea457611ea4613b72565b60200260200101516001600160a01b031603611ed35760405163f411c32760e01b815260040160405180910390fd5b600101611e67565b50611f18868381518110611ef157611ef1613b72565b6020026020010151868481518110611f0b57611f0b613b72565b6020026020010151612b59565b611f229082613ab4565b9050816001019150611e5c565b600c9092019190915550505050565b6001600160a01b0381165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a6020526040902080545f5160206142df5f395f51905f5291906301000000900460ff1615611fae5760405163f411c32760e01b815260040160405180910390fd5b826001600160a01b031663313ce5676040518163ffffffff1660e01b8152600401602060405180830381865afa158015611fea573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061200e9190613e42565b815460ff9190911663010000000263ff000000199091161781556002820180546001810182555f918252602082200180546001600160a01b0386166001600160a01b0319909116811790915560405190917f7db05e63d635a68c62fd7fd8f3107ae8ab584a383e102d1bd8a40f4c977e465f91a2505050565b6040516001600160a01b038085166024830152831660448201527fffffffff00000000000000000000000000000000000000000000000000000000821660648201525f908190819060840160408051601f19818403018152918152602080830180516001600160e01b03167fb7009613000000000000000000000000000000000000000000000000000000001781525f808052918290528351939450919290918a5afa15612140575f516020805191945081901c150291505b5094509492505050565b5f5f5f848060200190518101906121619190613e69565b915091505f61217a5f5160206142df5f395f51905f5290565b6008015f84801561218d5761218d613aa0565b801561219b5761219b613aa0565b81526020019081526020015f205f866001600160a01b03166001600160a01b031681526020019081526020015f205411156121db576001925050506122b7565b8051156122b1575f8280156121f2576121f2613aa0565b036122b1575f8180602001905181019061220c9190613c09565b90506001600160a01b038116156122af576040517f65e4ad9e0000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b0386811660248301528216906365e4ad9e906044016020604051808303815f875af1158015612281573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906122a59190613ead565b93505050506122b7565b505b5f925050505b92915050565b5f5f6060806060858060200190518101906122d89190613ca5565b939a9299509097509550909350915050565b5f808460098111156122fe576122fe613aa0565b036123ce575f5f5f5f5f8680602001905181019061231c9190613fa3565b945094509450945094505f612331828a612cb8565b86519091505f5b818110156123be576123b48389838151811061235657612356613b72565b602002602001015188848151811061237057612370613b72565b602002602001015188858151811061238a5761238a613b72565b602002602001015160ff168b86815181106123a7576123a7613b72565b6020026020010151612ce7565b9250600101612338565b508197505050505050505061088d565b60038460098111156123e2576123e2613aa0565b036123f65750670de0b6b3a764000061088d565b600284600981111561240a5761240a613aa0565b0361241657508161088d565b600484600981111561242a5761242a613aa0565b036124c8576040517f7a28fb88000000000000000000000000000000000000000000000000000000008152670de0b6b3a7640000600482015273ae7ab96520de3a18e5e111b5eaab095312d7fe8490637a28fb8890602401602060405180830381865afa15801561249d573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906124c19190613802565b905061088d565b60058460098111156124dc576124dc613aa0565b036125315773be9895146f7af43049ca1c1ae358b0541ea497046001600160a01b0316633ba0b9a96040518163ffffffff1660e01b8152600401602060405180830381865afa15801561249d573d5f5f3e3d5ffd5b600684600981111561254557612545613aa0565b0361259a5773ae78736cd615f374d3085123a210448e74fc63936001600160a01b031663e6aa216c6040518163ffffffff1660e01b8152600401602060405180830381865afa15801561249d573d5f5f3e3d5ffd5b60078460098111156125ae576125ae613aa0565b036126035773ac3e018457b222d93114458476f3e3416abbe38f6001600160a01b03166399530b066040518163ffffffff1660e01b8152600401602060405180830381865afa15801561249d573d5f5f3e3d5ffd5b600884600981111561261757612617613aa0565b0361263a575f828060200190518101906126319190613802565b915061088d9050565b600984600981111561264e5761264e613aa0565b036126e1575f5f8380602001905181019061266991906140ce565b9150915080826001600160a01b031663a035b1fe6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156126aa573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906126ce9190613802565b6126d89190613da7565b9250505061088d565b508161088d565b60605f5f5f6126f685612797565b90925090505f82801561270b5761270b613aa0565b0361279057808060200190518101906127249190613c09565b6001600160a01b03166301e1d1146040518163ffffffff1660e01b81526004015f60405180830381865afa15801561275e573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f1916820160405261278591908101906140fa565b935093505050915091565b5050915091565b5f6060828060200190518101906127ae9190613e69565b9094909350915050565b5f5f60205f8451602086015f885af1806127d7576040513d5f823e3d81fd5b50505f513d915081156127ee5780600114156127fb565b6001600160a01b0384163b155b15610656576040517f5274afe70000000000000000000000000000000000000000000000000000000081526001600160a01b0385166004820152602401610238565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b03167f095ea7b3000000000000000000000000000000000000000000000000000000001790526128a78482612df7565b610656576040516001600160a01b0384811660248301525f60448301526128db91869182169063095ea7b390606401611458565b61065684826127b8565b5f5f5f5f5f5f6128f4876122bd565b939850919650945092509050600185600981111561291457612914613aa0565b0361299c575f8380602001905181019061292e9190613c09565b9050806001600160a01b0316635ade93556040518163ffffffff1660e01b8152600401602060405180830381865afa15801561296c573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906129909190613802565b98975050505050505050565b5f818060200190518101906129b19190613d54565b5090505f6129cb87878787866001600160801b0316612e40565b9098509050878110156129dc578097505b50505050505050919050565b5f6001600160801b03821115612a34576040517f6dfcc6500000000000000000000000000000000000000000000000000000000081526080600482015260248101839052604401610238565b5090565b427f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c8055805160609081905f5160206142df5f395f51905f52905f9067ffffffffffffffff811115612a8b57612a8b6131df565b604051908082528060200260200182016040528015612ab4578160200160208202803683370190505b5092505b8451811015612b0f575f858281518110612ad457612ad4613b72565b60200260200101519050612ae9878285612edd565b848381518110612afb57612afb613b72565b602090810291909101015250600101612ab8565b600b8201546040805188815260208101929092527f141751092cf7f1b8dd572383f04983a12e1767842801592e3f37663cc7945ad5910160405180910390a1509294909350915050565b5f815f03612b93576040517f1f2a200500000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b306001600160a01b03841603612bd5576040517fb387a23800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c828054600181019091557fbc23df6a4455ba59ecbb7370f929cc2ed02454c98c8e7c9671c82c6d946778300180546001600160a01b0319166001600160a01b0385169081179091555f8181527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c836020908152604091829020859055815185815291515f5160206142df5f395f51905f5293927f40c340f65e17194d14ddddb073d3c9f888e3cb52b5aae0c6c7706b4fbc905fac92908290030190a2509092915050565b5f80836001811115612ccc57612ccc613aa0565b03612ce05750670de0b6b3a76400006122b7565b50806122b7565b5f5f5f866001600160a01b031663feaf968c6040518163ffffffff1660e01b815260040160a060405180830381865afa158015612d26573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612d4a91906141ae565b509350509250505f82131580612d6e575063ffffffff8416612d6c824261382d565b115b15612da5576040517fae19356300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8560ff16600103612dd857612dbb85600a6142d3565b612dc5838a613ac7565b612dcf9190613da7565b92505050612dee565b81612de486600a6142d3565b612dc5908a613ac7565b95945050505050565b5f5f5f5f60205f8651602088015f8a5af192503d91505f519050828015612e3657508115612e285780600114612e36565b5f866001600160a01b03163b115b9695505050505050565b5f5f612e5586670de0b6b3a7640000866122ea565b9050612e628782876122ea565b9150612e76670de0b6b3a764000083613ac7565b612e8884670de0b6b3a764000061382d565b612e929083613ac7565b108015612eca5750612eac83670de0b6b3a7640000613ab4565b612eb69082613ac7565b612ec8670de0b6b3a764000084613ac7565b105b15612ed3578091505b9550959350505050565b6001600160a01b0382165f908152600e82016020526040812054600c830154612f07918691612ffd565b90506001600160a01b038316612f935781546040517f2b471d8e000000000000000000000000000000000000000000000000000000008152600481018390523060248201526001600160a01b0390911690632b471d8e906044015f604051808303815f87803b158015612f78575f5ffd5b505af1158015612f8a573d5f5f3e3d5ffd5b50505050612fa9565b8154612fa9906001600160a01b0316848361142b565b600b820154604080518381526001600160a01b038616602082015280820192909252517f17265974e980c0c028871fefa3438a14d11f8008db1fe6da5d98c45bf64a64c89181900360600190a19392505050565b5f5f5f61300a86866130ad565b91509150815f0361302e5783818161302457613024613d93565b049250505061088d565b8184116130455761304560038515026011186130c9565b5f848688095f868103871696879004966002600389028118808a02820302808a02820302808a02820302808a02820302808a02820302808a02909103029181900381900460010185841190960395909502919093039390930492909217029150509392505050565b5f805f1983850993909202808410938190039390930393915050565b634e487b715f52806020526024601cfd5b5080545f825560030160049004905f5260205f20908101906102c091906131a9565b508054613108906137ca565b5f825580601f10613117575050565b601f0160209004905f5260205f20908101906102c091906131a9565b5080545f8255905f5260205f20908101906102c091906131a9565b828054828255905f5260205f209081019282156131a1579160200282015b828111156131a157825182546001600160a01b0319166001600160a01b0390911617825560209092019160019091019061316c565b50612a349291505b5b80821115612a34575f81556001016131aa565b6001600160a01b03811681146102c0575f5ffd5b60ff811681146102c0575f5ffd5b634e487b7160e01b5f52604160045260245ffd5b6040805190810167ffffffffffffffff81118282101715613216576132166131df565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715613245576132456131df565b604052919050565b5f67ffffffffffffffff821115613266576132666131df565b50601f01601f191660200190565b5f82601f830112613283575f5ffd5b81356132966132918261324d565b61321c565b8181528460208386010111156132aa575f5ffd5b816020850160208301375f918101602001919091529392505050565b5f5f5f606084860312156132d8575f5ffd5b83356132e3816131bd565b925060208401356132f3816131d1565b9150604084013567ffffffffffffffff81111561330e575f5ffd5b61331a86828701613274565b9150509250925092565b5f60208284031215613334575f5ffd5b813561088d816131bd565b80151581146102c0575f5ffd5b80356133578161333f565b919050565b5f5f6040838503121561336d575f5ffd5b8235613378816131bd565b915060208301356133888161333f565b809150509250929050565b5f67ffffffffffffffff8211156133ac576133ac6131df565b5060051b60200190565b5f5f5f606084860312156133c8575f5ffd5b83356133d3816131bd565b925060208401356133e38161333f565b9150604084013567ffffffffffffffff8111156133fe575f5ffd5b84016040818703121561340f575f5ffd5b6134176131f3565b813567ffffffffffffffff81111561342d575f5ffd5b8201601f8101881361343d575f5ffd5b803561344b61329182613393565b8082825260208201915060208360051b85010192508a83111561346c575f5ffd5b6020840193505b82841015613497578335613486816131bd565b825260209384019390910190613473565b8452505050602082013567ffffffffffffffff8111156134b5575f5ffd5b6134c188828501613274565b60208301525080925050509250925092565b5f602082840312156134e3575f5ffd5b813567ffffffffffffffff8116811461088d575f5ffd5b5f5f5f5f6080858703121561350d575f5ffd5b8435613518816131bd565b93506020850135613528816131bd565b92506040850135613538816131bd565b9396929550929360600135925050565b600281106102c0575f5ffd5b5f5f60408385031215613565575f5ffd5b8235613570816131bd565b9150602083013561338881613548565b5f5f60408385031215613591575f5ffd5b823561359c816131bd565b946020939093013593505050565b5f5f5f606084860312156135bc575f5ffd5b83356135c7816131bd565b925060208401356135d7816131bd565b929592945050506040919091013590565b5f5f604083850312156135f9575f5ffd5b8235613604816131bd565b9150602083013567ffffffffffffffff81111561361f575f5ffd5b61362b85828601613274565b9150509250929050565b6001600160801b03811681146102c0575f5ffd5b5f5f5f6060848603121561365b575f5ffd5b8335613666816131bd565b9250602084013561367681613635565b915060408401356136868161333f565b809150509250925092565b5f82601f8301126136a0575f5ffd5b81356136ae61329182613393565b8082825260208201915060208360051b8601019250858311156136cf575f5ffd5b602085015b838110156136ec5780358352602092830192016136d4565b5095945050505050565b5f5f5f60608486031215613708575f5ffd5b833567ffffffffffffffff81111561371e575f5ffd5b8401601f8101861361372e575f5ffd5b803561373c61329182613393565b8082825260208201915060208360051b85010192508883111561375d575f5ffd5b6020840193505b82841015613788578335613777816131bd565b825260209384019390910190613764565b9550505050602084013567ffffffffffffffff8111156137a6575f5ffd5b6137b286828701613691565b9250506137c16040850161334c565b90509250925092565b600181811c908216806137de57607f821691505b6020821081036137fc57634e487b7160e01b5f52602260045260245ffd5b50919050565b5f60208284031215613812575f5ffd5b5051919050565b634e487b7160e01b5f52601160045260245ffd5b818103818111156122b7576122b7613819565b5f5f8585111561384e575f5ffd5b8386111561385a575f5ffd5b5050820193919092039150565b80357fffffffff0000000000000000000000000000000000000000000000000000000081169060048410156138c6577fffffffff00000000000000000000000000000000000000000000000000000000808560040360031b1b82161691505b5092915050565b6001600160a01b038416815260406020820152816040820152818360608301375f818301606090810191909152601f909201601f1916010192915050565b601f82111561024c57805f5260205f20601f840160051c810160208510156139305750805b601f840160051c820191505b8181101561394f575f815560010161393c565b5050505050565b815167ffffffffffffffff811115613970576139706131df565b6139848161397e84546137ca565b8461390b565b6020601f8211600181146139b6575f831561399f5750848201515b5f19600385901b1c1916600184901b17845561394f565b5f84815260208120601f198516915b828110156139e557878501518255602094850194600190920191016139c5565b5084821015613a0257868401515f19600387901b60f8161c191681555b50505050600190811b01905550565b604081525f5f8454613a22816137ca565b806040860152600182165f8114613a405760018114613a5c57613a8d565b60ff1983166060870152606082151560051b8701019350613a8d565b875f5260205f205f5b83811015613a8457815488820160600152600190910190602001613a65565b87016060019450505b50505060ff84166020840152905061088d565b634e487b7160e01b5f52602160045260245ffd5b808201808211156122b7576122b7613819565b80820281158282048414176122b7576122b7613819565b600a8110613aee57613aee613aa0565b9052565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b613b2a8187613ade565b613b376020820186613ade565b60a060408201525f613b4c60a0830186613af2565b8281036060840152613b5e8186613af2565b905082810360808401526129908185613af2565b634e487b7160e01b5f52603260045260245ffd5b634e487b7160e01b5f52603160045260245ffd5b602080825282516040838301528051606084018190525f929190910190829060808501905b80831015613beb576001600160a01b038451168252602082019150602084019350600183019250613bbf565b506020860151858203601f190160408701529250612e368184613af2565b5f60208284031215613c19575f5ffd5b815161088d816131bd565b82151581526040810160028310613c3d57613c3d613aa0565b8260208301529392505050565b8051600a8110613357575f5ffd5b5f82601f830112613c67575f5ffd5b8151613c756132918261324d565b818152846020838601011115613c89575f5ffd5b8160208501602083015e5f918101602001919091529392505050565b5f5f5f5f5f60a08688031215613cb9575f5ffd5b613cc286613c4a565b9450613cd060208701613c4a565b9350604086015167ffffffffffffffff811115613ceb575f5ffd5b613cf788828901613c58565b935050606086015167ffffffffffffffff811115613d13575f5ffd5b613d1f88828901613c58565b925050608086015167ffffffffffffffff811115613d3b575f5ffd5b613d4788828901613c58565b9150509295509295909350565b5f5f60408385031215613d65575f5ffd5b8251613d7081613635565b602084015190925061338881613635565b602081525f61088d6020830184613af2565b634e487b7160e01b5f52601260045260245ffd5b5f82613dc157634e487b7160e01b5f52601260045260245ffd5b500490565b6001600160d81b0381811683821601908111156122b7576122b7613819565b6001600160801b0381811683821601908111156122b7576122b7613819565b6001600160d81b0382811682821603908111156122b7576122b7613819565b6001600160801b0382811682821603908111156122b7576122b7613819565b5f60208284031215613e52575f5ffd5b815161088d816131d1565b600181106102c0575f5ffd5b5f5f60408385031215613e7a575f5ffd5b8251613e8581613e5d565b602084015190925067ffffffffffffffff811115613ea1575f5ffd5b61362b85828601613c58565b5f60208284031215613ebd575f5ffd5b815161088d8161333f565b5f82601f830112613ed7575f5ffd5b8151613ee561329182613393565b8082825260208201915060208360051b860101925085831115613f06575f5ffd5b602085015b838110156136ec57805163ffffffff81168114613f26575f5ffd5b835260209283019201613f0b565b5f82601f830112613f43575f5ffd5b8151613f5161329182613393565b8082825260208201915060208360051b860101925085831115613f72575f5ffd5b602085015b838110156136ec578051613f8a816131d1565b835260209283019201613f77565b805161335781613548565b5f5f5f5f5f60a08688031215613fb7575f5ffd5b855167ffffffffffffffff811115613fcd575f5ffd5b8601601f81018813613fdd575f5ffd5b8051613feb61329182613393565b8082825260208201915060208360051b85010192508a83111561400c575f5ffd5b6020840193505b82841015614037578351614026816131bd565b825260209384019390910190614013565b80985050505050602086015167ffffffffffffffff811115614057575f5ffd5b61406388828901613ec8565b945050604086015167ffffffffffffffff81111561407f575f5ffd5b61408b88828901613f34565b935050606086015167ffffffffffffffff8111156140a7575f5ffd5b6140b388828901613f34565b9250506140c260808701613f98565b90509295509295909350565b5f5f604083850312156140df575f5ffd5b82516140ea816131bd565b6020939093015192949293505050565b5f5f6040838503121561410b575f5ffd5b825167ffffffffffffffff811115614121575f5ffd5b8301601f81018513614131575f5ffd5b805161413f61329182613393565b8082825260208201915060208360051b850101925087831115614160575f5ffd5b6020840193505b82841015614182578351825260209384019390910190614167565b6020969096015195979596505050505050565b805169ffffffffffffffffffff81168114613357575f5ffd5b5f5f5f5f5f60a086880312156141c2575f5ffd5b6141cb86614195565b602087015160408801516060890151929750909550935091506140c260808701614195565b6001815b600184111561422b5780850481111561420f5761420f613819565b600184161561421d57908102905b60019390931c9280026141f4565b935093915050565b5f82614241575060016122b7565b8161424d57505f6122b7565b8160018114614263576002811461426d57614289565b60019150506122b7565b60ff84111561427e5761427e613819565b50506001821b6122b7565b5060208310610133831016604e8410600b84101617156142ac575081810a6122b7565b6142b85f1984846141f0565b805f19048211156142cb576142cb613819565b029392505050565b5f61088d838361423356fe4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75a2646970667358221220267448d84bd781563949caeb1b4590cff220d6b31ffd62af8c37f2b79b199c6164736f6c634300081c0033",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -759,6 +820,9 @@
       "setCollateralManager(address,bool,(address[],bytes))": {
         "details": "Funds need to have been withdrawn from the eventual previous manager prior to this call"
       },
+      "setSwapRouter(address)": {
+        "details": "The payload is executed with a raw call, so any router can be configured. It is chain specific and must be set on every deployment before rewards can be sold"
+      },
       "updatePayees(address[],uint256[],bool)": {
         "params": {
           "_payees": "The new payee addresses",
@@ -782,9 +846,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "3353000",
-        "executionCost": "3729",
-        "totalCost": "3356729"
+        "codeDepositCost": "3440800",
+        "executionCost": "3842",
+        "totalCost": "3444642"
       },
       "external": {
         "addCollateral(address)": "infinite",
@@ -795,6 +859,7 @@
         "setAccessManager(address)": "infinite",
         "setCollateralManager(address,bool,(address[],bytes))": "infinite",
         "setOracle(address,bytes)": "infinite",
+        "setSwapRouter(address)": "infinite",
         "setWhitelistStatus(address,uint8,bytes)": "infinite",
         "toggleTrusted(address,uint8)": "infinite",
         "updateOracle(address)": "infinite",
@@ -804,12 +869,17 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AboveCap\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyAdded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CollateralBacked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccessManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParams\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidWhitelistStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ManagerHasAssets\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OracleUpdateFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentAllowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requestedDecrease\",\"type\":\"uint256\"}],\"name\":\"SafeERC20FailedDecreaseAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"indexed\":false,\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"CollateralManagerSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"}],\"name\":\"CollateralWhitelistStatusUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleasedToPayee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"OracleSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"PayeeAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"ReservesAdjusted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"SlippageToleranceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"SurplusBufferRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isTrusted\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"enum TrustedType\",\"name\":\"trustedType\",\"type\":\"uint8\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"addCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"adjustStablecoins\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"changeAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"}],\"name\":\"revokeCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAccessManager\",\"type\":\"address\"}],\"name\":\"setAccessManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"setCollateralManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"setOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"}],\"name\":\"setWhitelistStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"enum TrustedType\",\"name\":\"t\",\"type\":\"uint8\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"updateOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_payees\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_shares\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"_skipRelease\",\"type\":\"bool\"}],\"name\":\"updatePayees\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"updateSlippageTolerance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"updateSurplusBufferRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `SettersGovernor` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedDecreaseAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failed `decreaseAllowance` request.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"addCollateral(address)\":{\"details\":\"Collateral assets with a fee on transfer are not supported by the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"details\":\"The amount passed here must be an absolute amount\"},\"changeAllowance(address,address,uint256)\":{\"details\":\"This function can typically be used to grant allowance to a newly added manager for it to pull the funds associated to the collateral it corresponds to\"},\"recoverERC20(address,address,address,uint256)\":{\"details\":\"No check is made on the collateral that is redeemed: this function could typically be used by a governance during a manual rebalance of the reserves of the system`collateral` is different from `token` only in the case of a managed collateral\"},\"revokeCollateral(address,bool)\":{\"details\":\"Require `collatInfo.normalizedStables == 0`, that is to say that the collateral is not used to back stablesThe system may still have a non null balance of the collateral that is revoked: this should later be handled through a recoverERC20 callFunds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is true\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"details\":\"Funds need to have been withdrawn from the eventual previous manager prior to this call\"},\"updatePayees(address[],uint256[],bool)\":{\"params\":{\"_payees\":\"The new payee addresses\",\"_shares\":\"The new shares for each payee\",\"_skipRelease\":\"If true, skips the automatic income release before updating\"}},\"updateSlippageTolerance(address,uint256)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when calling the `processSurplus` function\"},\"updateSurplusBufferRatio(uint64)\":{\"details\":\"The surplus buffer ratio is the minimum collateral ratio required after surplus processing\",\"params\":{\"_surplusBufferRatio\":\"The new surplus buffer ratio in BASE_9\"}}},\"title\":\"SettersGovernor\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addCollateral(address)\":{\"notice\":\"Add `collateral` as a supported collateral in the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"notice\":\"Adjusts the amount of stablecoins issued from `collateral` by `amount`\"},\"changeAllowance(address,address,uint256)\":{\"notice\":\"Sets the allowance of the contract on `token` for `spender` to `amount`\"},\"recoverERC20(address,address,address,uint256)\":{\"notice\":\"Recovers `amount` of `token` from the Parallelizer contract\"},\"revokeCollateral(address,bool)\":{\"notice\":\"Revokes `collateral` from the system\"},\"setAccessManager(address)\":{\"notice\":\"Sets a new access manager address\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"notice\":\"Sets (or unsets) a collateral manager  `collateral`\"},\"setOracle(address,bytes)\":{\"notice\":\"Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations\"},\"setWhitelistStatus(address,uint8,bytes)\":{\"notice\":\"Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist\"},\"toggleTrusted(address,uint8)\":{\"notice\":\"Changes the trusted status for `sender` when for selling rewards or updating the normalizer\"},\"updateOracle(address)\":{\"notice\":\"Update oracle data for a given `collateral`\"},\"updatePayees(address[],uint256[],bool)\":{\"notice\":\"Updates the payees and their shares\"},\"updateSlippageTolerance(address,uint256)\":{\"notice\":\"Updates the slippage tolerance for a `collateral`\"},\"updateSurplusBufferRatio(uint64)\":{\"notice\":\"Updates the surplus buffer ratio\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/SettersGovernor.sol\":\"SettersGovernor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xd4d195b62841c28dd5f248d09e682c3c81bda24b471cd8a5d8efe498519ea50d\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/SettersGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { ISettersGovernor } from \\\"contracts/interfaces/ISetters.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibSetters } from \\\"../libraries/LibSetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title SettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\\ncontract SettersGovernor is AccessManagedModifiers, ISettersGovernor {\\n  using SafeERC20 for IERC20;\\n\\n  event Recovered(address indexed token, address indexed to, uint256 amount);\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev No check is made on the collateral that is redeemed: this function could typically be used by a\\n  /// governance during a manual rebalance of the reserves of the system\\n  /// @dev `collateral` is different from `token` only in the case of a managed collateral\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);\\n    else token.safeTransfer(to, amount);\\n    emit Recovered(address(token), to, amount);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setAccessManager(address _newAccessManager) external restricted {\\n    LibSetters.setAccessManager(IAccessManager(_newAccessManager));\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the\\n  /// funds associated to the collateral it corresponds to\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {\\n    uint256 currentAllowance = token.allowance(address(this), spender);\\n    if (currentAllowance < amount) {\\n      token.safeIncreaseAllowance(spender, amount - currentAllowance);\\n    } else if (currentAllowance > amount) {\\n      token.safeDecreaseAllowance(spender, currentAllowance - amount);\\n    }\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function toggleTrusted(address sender, TrustedType t) external restricted {\\n    LibSetters.toggleTrusted(sender, t);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Collateral assets with a fee on transfer are not supported by the system\\n  function addCollateral(address collateral) external restricted {\\n    LibSetters.addCollateral(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev The amount passed here must be an absolute amount\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {\\n    LibSetters.adjustStablecoins(collateral, amount, increase);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral\\n  /// is not used to back stables\\n  /// @dev The system may still have a non null balance of the collateral that is revoked: this should later\\n  /// be handled through a recoverERC20 call\\n  /// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is\\n  /// true\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {\\n    LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setOracle(address collateral, bytes memory oracleConfig) external restricted {\\n    LibSetters.setOracle(collateral, oracleConfig);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateOracle(address collateral) external {\\n    if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    LibOracle.updateOracle(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setWhitelistStatus(\\n    address collateral,\\n    uint8 whitelistStatus,\\n    bytes memory whitelistData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external restricted {\\n    LibSetters.updatePayees(_payees, _shares, _skipRelease);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external restricted {\\n    LibSetters.updateSlippageTolerance(collateral, slippageTolerance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {\\n    LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);\\n  }\\n}\\n\",\"keccak256\":\"0x3d0d0351ef8f06a401c421d2f76b4227e4819935583ad29f44fc6dc59f5ea021\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport { LibSurplus } from \\\"./LibSurplus.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { LibDiamond } from \\\"./LibDiamond.sol\\\";\\nimport { LibWhitelist } from \\\"./LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibSetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibSetters.sol\\nlibrary LibSetters {\\n  using SafeCast for uint256;\\n\\n  event CollateralAdded(address indexed collateral);\\n  event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);\\n  event CollateralRevoked(address indexed collateral);\\n  event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);\\n  event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);\\n  event OracleSet(address indexed collateral, bytes oracleConfig);\\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n  event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);\\n  event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);\\n  event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);\\n  event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);\\n  event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);\\n  event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);\\n  event PayeeAdded(address indexed payee, uint256 shares);\\n  event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);\\n  event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GOVERNOR ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `setAccessManager`\\n  function setAccessManager(IAccessManager _newAccessManager) internal {\\n    if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();\\n    DiamondStorage storage ds = s.diamondStorage();\\n    address previousAccessManager = address(ds.accessManager);\\n    ds.accessManager = _newAccessManager;\\n    emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));\\n  }\\n\\n  /// @notice Internal version of `setCollateralManager`\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    internal\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    if (managerData.config.length != 0) {\\n      // The first subCollateral given should be the actual collateral asset\\n      if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();\\n      // Sanity check on the manager data that is passed\\n      LibManager.parseManagerConfig(managerData.config);\\n      collatInfo.isManaged = 1;\\n    } else {\\n      collatInfo.isManaged = 0;\\n    }\\n    collatInfo.managerData = managerData;\\n    emit CollateralManagerSet(collateral, managerData);\\n  }\\n\\n  /// @notice Internal version of `toggleTrusted`\\n  function toggleTrusted(address sender, TrustedType t) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 trustedStatus;\\n    if (t == TrustedType.Updater) {\\n      trustedStatus = 1 - ts.isTrusted[sender];\\n      ts.isTrusted[sender] = trustedStatus;\\n    } else {\\n      trustedStatus = 1 - ts.isSellerTrusted[sender];\\n      ts.isSellerTrusted[sender] = trustedStatus;\\n    }\\n    emit TrustedToggled(sender, trustedStatus == 1, t);\\n  }\\n\\n  /// @notice Internal version of `addCollateral`\\n  function addCollateral(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals != 0) revert AlreadyAdded();\\n    collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());\\n    ts.collateralList.push(collateral);\\n    emit CollateralAdded(collateral);\\n  }\\n\\n  /// @notice Internal version of `adjustStablecoins`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();\\n    if (increase) {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables + normalizedAmount;\\n      if (uint256(collatInfo.normalizedStables) * uint256(ts.normalizer) / BASE_27 > collatInfo.stablecoinCap) {\\n        revert AboveCap();\\n      }\\n    } else {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables - normalizedAmount;\\n    }\\n    emit ReservesAdjusted(collateral, amount, increase);\\n  }\\n\\n  /// @notice Internal version of `revokeCollateral`\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (collatInfo.normalizedStables > 0) revert CollateralBacked();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    delete ts.collaterals[collateral];\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 length = collateralListMem.length;\\n    for (uint256 i; i < length - 1; ++i) {\\n      if (collateralListMem[i] == collateral) {\\n        ts.collateralList[i] = collateralListMem[length - 1];\\n        break;\\n      }\\n    }\\n    ts.collateralList.pop();\\n    emit CollateralRevoked(collateral);\\n  }\\n\\n  /// @notice Internal version of `setOracle`\\n  function setOracle(address collateral, bytes memory oracleConfig) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    (,,,, bytes memory hyperparameters) =\\n      abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    if (userDeviation > burnRatioDeviation) revert InvalidParams();\\n    // Checks oracle validity\\n    LibOracle.readMint(oracleConfig);\\n    collatInfo.oracleConfig = oracleConfig;\\n    emit OracleSet(collateral, oracleConfig);\\n  }\\n\\n  /// @notice Internal version of `setWhitelistStatus`\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {\\n    if (whitelistStatus > 1) revert InvalidWhitelistStatus();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (whitelistStatus == 1) {\\n      // Sanity check\\n      LibWhitelist.checkWhitelist(whitelistData, address(this));\\n      collatInfo.whitelistData = whitelistData;\\n    } else {\\n      // If whitelist is revoked, clear the whitelist data\\n      collatInfo.whitelistData = \\\"\\\";\\n    }\\n    collatInfo.onlyWhitelisted = whitelistStatus;\\n    emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GUARDIAN ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `pause` \\u2014 sets the action's live flag to `0`\\n  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance\\n  /// call cannot pass silently\\n  function pause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 0);\\n  }\\n\\n  /// @notice Internal version of `unpause` \\u2014 sets the action's live flag to `1`\\n  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance\\n  /// call cannot pass silently\\n  function unpause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 1);\\n  }\\n\\n  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`\\n  /// to unpause. Reverts on no-op transitions.\\n  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;\\n      if (currentIsLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      if (action == ActionType.Mint) {\\n        collatInfo.isMintLive = targetIsLive;\\n      } else {\\n        collatInfo.isBurnLive = targetIsLive;\\n      }\\n    } else {\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      if (ts.isRedemptionLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      ts.isRedemptionLive = targetIsLive;\\n    }\\n    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);\\n  }\\n\\n  /// @notice Internal version of `setFees`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);\\n    if (mint) {\\n      collatInfo.xFeeMint = xFee;\\n      collatInfo.yFeeMint = yFee;\\n    } else {\\n      collatInfo.xFeeBurn = xFee;\\n      collatInfo.yFeeBurn = yFee;\\n    }\\n    emit FeesSet(collateral, xFee, yFee, mint);\\n  }\\n\\n  /// @notice Internal version of `setRedemptionCurveParams`\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    LibSetters.checkFees(xFee, yFee, ActionType.Redeem);\\n    ts.xRedemptionCurve = xFee;\\n    ts.yRedemptionCurve = yFee;\\n    emit RedemptionCurveParamsSet(xFee, yFee);\\n  }\\n\\n  /// @notice Internal version of `toggleWhitelist`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];\\n    ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;\\n    emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);\\n  }\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a collateral\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    collatInfo.stablecoinCap = stablecoinCap;\\n    emit StablecoinCapSet(collateral, stablecoinCap);\\n  }\\n\\n  /// @notice Internal version of `updatePayees`\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) internal {\\n    if (_payees.length == 0 || _payees.length > MAX_PAYEES) revert InvalidLengths();\\n    if (_payees.length != _shares.length) revert ArrayLengthMismatch();\\n    /// @dev Distribute the fees before updating the fee receivers.\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!_skipRelease) {\\n      uint256 income = ts.tokenP.balanceOf(address(this));\\n      if (income > 0 && ts.payees.length > 0) {\\n        LibSurplus.release(income, ts.payees);\\n      }\\n    }\\n\\n    // Zero out stale shares for old payees\\n    uint256 i = 0;\\n    for (; i < ts.payees.length; ++i) {\\n      ts.shares[ts.payees[i]] = 0;\\n    }\\n    delete ts.payees;\\n    uint256 _totalShares = 0;\\n    i = 0;\\n    for (; i < _payees.length; ++i) {\\n      for (uint256 j = 0; j < i; ++j) {\\n        if (_payees[j] == _payees[i]) revert AlreadyAdded();\\n      }\\n      _totalShares += _addPayee(_payees[i], _shares[i]);\\n    }\\n    ts.totalShares = _totalShares;\\n  }\\n\\n  /// @notice Internal version of `updateSlippageTolerance`\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) internal {\\n    if (slippageTolerance > BASE_9) revert InvalidRate();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.slippageTolerance[collateral] = slippageTolerance;\\n    emit SlippageToleranceUpdated(collateral, slippageTolerance);\\n  }\\n\\n  /// @notice Internal version of `updateSurplusBufferRatio`\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {\\n    if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.surplusBufferRatio = _surplusBufferRatio;\\n    emit SurplusBufferRatioUpdated(_surplusBufferRatio);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions\\n  function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {\\n    uint256 n = xFee.length;\\n    if (n != yFee.length || n == 0) revert InvalidParams();\\n    if (\\n      // Mint inflexion points should be in [0,BASE_9[\\n      // We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9\\n      // Hence we consider BASE_12 as the max value (100% fees) for yFeeMint\\n      // Burn inflexion points should be in [0,BASE_9] but fees should be constant in\\n      // the first segment [BASE_9, x_{n-1}[\\n      // Redemption inflexion points should be in [0,BASE_9]\\n      (action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))\\n        || (action == ActionType.Burn\\n          && (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1]))))\\n        || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))\\n    ) {\\n      revert InvalidParams();\\n    }\\n\\n    for (uint256 i; i < n - 1; ++i) {\\n      if (\\n        // xFee strictly increasing and yFee increasing for mints\\n        // xFee strictly decreasing and yFee increasing for burns\\n        // xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions\\n        (action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))\\n      ) revert InvalidParams();\\n    }\\n\\n    // If a mint or burn fee is negative, we need to check that accounts atomically minting\\n    // (from any collateral) and then burning cannot get more than their initial value\\n    if (yFee[0] < 0) {\\n      if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 length = collateralListMem.length;\\n      if (action == ActionType.Mint) {\\n        // This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;\\n          if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n      if (action == ActionType.Burn) {\\n        // This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;\\n          if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n    }\\n  }\\n\\n  /// @notice Add a new fee receiver.\\n  /// @param _payee The address of the fee receiver.\\n  /// @param _shares The number of shares assigned to the fee receiver.\\n  function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {\\n    if (_shares == 0) revert ZeroAmount();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n\\n    ts.payees.push(_payee);\\n    ts.shares[_payee] = _shares;\\n    emit PayeeAdded(_payee, _shares);\\n    return _shares;\\n  }\\n}\\n\",\"keccak256\":\"0x9e41915e7fb03ef3b054f7ce0b7ab297e3b8f5c05ab1e7ebe072e22f11b22362\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AboveCap\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyAdded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CollateralBacked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccessManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParams\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidPayee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidWhitelistStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ManagerHasAssets\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OracleUpdateFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentAllowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requestedDecrease\",\"type\":\"uint256\"}],\"name\":\"SafeERC20FailedDecreaseAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"indexed\":false,\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"CollateralManagerSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"}],\"name\":\"CollateralWhitelistStatusUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleasedToPayee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"OracleSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"previousTarget\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newTarget\",\"type\":\"uint256\"}],\"name\":\"OracleTargetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"PayeeAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"ReservesAdjusted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"SlippageToleranceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"SurplusBufferRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"swapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isTrusted\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"enum TrustedType\",\"name\":\"trustedType\",\"type\":\"uint8\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"addCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"adjustStablecoins\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"changeAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"}],\"name\":\"revokeCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAccessManager\",\"type\":\"address\"}],\"name\":\"setAccessManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"setCollateralManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"setOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"swapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"}],\"name\":\"setWhitelistStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"enum TrustedType\",\"name\":\"t\",\"type\":\"uint8\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"updateOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_payees\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_shares\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"_skipRelease\",\"type\":\"bool\"}],\"name\":\"updatePayees\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"updateSlippageTolerance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"updateSurplusBufferRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `SettersGovernor` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedDecreaseAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failed `decreaseAllowance` request.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"addCollateral(address)\":{\"details\":\"Collateral assets with a fee on transfer are not supported by the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"details\":\"The amount passed here must be an absolute amount\"},\"changeAllowance(address,address,uint256)\":{\"details\":\"This function can typically be used to grant allowance to a newly added manager for it to pull the funds associated to the collateral it corresponds to\"},\"recoverERC20(address,address,address,uint256)\":{\"details\":\"No check is made on the collateral that is redeemed: this function could typically be used by a governance during a manual rebalance of the reserves of the system`collateral` is different from `token` only in the case of a managed collateral\"},\"revokeCollateral(address,bool)\":{\"details\":\"Require `collatInfo.normalizedStables == 0`, that is to say that the collateral is not used to back stablesThe system may still have a non null balance of the collateral that is revoked: this should later be handled through a recoverERC20 callFunds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is true\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"details\":\"Funds need to have been withdrawn from the eventual previous manager prior to this call\"},\"setSwapRouter(address)\":{\"details\":\"The payload is executed with a raw call, so any router can be configured. It is chain specific and must be set on every deployment before rewards can be sold\"},\"updatePayees(address[],uint256[],bool)\":{\"params\":{\"_payees\":\"The new payee addresses\",\"_shares\":\"The new shares for each payee\",\"_skipRelease\":\"If true, skips the automatic income release before updating\"}},\"updateSlippageTolerance(address,uint256)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when calling the `processSurplus` function\"},\"updateSurplusBufferRatio(uint64)\":{\"details\":\"The surplus buffer ratio is the minimum collateral ratio required after surplus processing\",\"params\":{\"_surplusBufferRatio\":\"The new surplus buffer ratio in BASE_9\"}}},\"title\":\"SettersGovernor\",\"version\":1},\"userdoc\":{\"events\":{\"OracleTargetUpdated(address,uint256,uint256)\":{\"notice\":\"Emitted when a MAX target price is ratcheted up by `updateOracle`\"}},\"kind\":\"user\",\"methods\":{\"addCollateral(address)\":{\"notice\":\"Add `collateral` as a supported collateral in the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"notice\":\"Adjusts the amount of stablecoins issued from `collateral` by `amount`\"},\"changeAllowance(address,address,uint256)\":{\"notice\":\"Sets the allowance of the contract on `token` for `spender` to `amount`\"},\"recoverERC20(address,address,address,uint256)\":{\"notice\":\"Recovers `amount` of `token` from the Parallelizer contract\"},\"revokeCollateral(address,bool)\":{\"notice\":\"Revokes `collateral` from the system\"},\"setAccessManager(address)\":{\"notice\":\"Sets a new access manager address\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"notice\":\"Sets (or unsets) a collateral manager  `collateral`\"},\"setOracle(address,bytes)\":{\"notice\":\"Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations\"},\"setSwapRouter(address)\":{\"notice\":\"Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\"},\"setWhitelistStatus(address,uint8,bytes)\":{\"notice\":\"Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist\"},\"toggleTrusted(address,uint8)\":{\"notice\":\"Changes the trusted status for `sender` when for selling rewards or updating the normalizer\"},\"updateOracle(address)\":{\"notice\":\"Update oracle data for a given `collateral`\"},\"updatePayees(address[],uint256[],bool)\":{\"notice\":\"Updates the payees and their shares\"},\"updateSlippageTolerance(address,uint256)\":{\"notice\":\"Updates the slippage tolerance for a `collateral`\"},\"updateSurplusBufferRatio(uint64)\":{\"notice\":\"Updates the surplus buffer ratio\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/SettersGovernor.sol\":\"SettersGovernor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n\\n  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain\\n  /// specific and must be set on every deployment before rewards can be sold\\n  function setSwapRouter(address swapRouter) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xe62d2880420afb053498b01f1def17d4c8e2c6c9b48cc5a71d013150a5ca8db4\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/SettersGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { ISettersGovernor } from \\\"contracts/interfaces/ISetters.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibSetters } from \\\"../libraries/LibSetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title SettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\\ncontract SettersGovernor is AccessManagedModifiers, ISettersGovernor {\\n  using SafeERC20 for IERC20;\\n\\n  event Recovered(address indexed token, address indexed to, uint256 amount);\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev No check is made on the collateral that is redeemed: this function could typically be used by a\\n  /// governance during a manual rebalance of the reserves of the system\\n  /// @dev `collateral` is different from `token` only in the case of a managed collateral\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);\\n    else token.safeTransfer(to, amount);\\n    emit Recovered(address(token), to, amount);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setAccessManager(address _newAccessManager) external restricted {\\n    LibSetters.setAccessManager(IAccessManager(_newAccessManager));\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the\\n  /// funds associated to the collateral it corresponds to\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {\\n    uint256 currentAllowance = token.allowance(address(this), spender);\\n    if (currentAllowance < amount) {\\n      token.safeIncreaseAllowance(spender, amount - currentAllowance);\\n    } else if (currentAllowance > amount) {\\n      token.safeDecreaseAllowance(spender, currentAllowance - amount);\\n    }\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function toggleTrusted(address sender, TrustedType t) external restricted {\\n    LibSetters.toggleTrusted(sender, t);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Collateral assets with a fee on transfer are not supported by the system\\n  function addCollateral(address collateral) external restricted {\\n    LibSetters.addCollateral(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev The amount passed here must be an absolute amount\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {\\n    LibSetters.adjustStablecoins(collateral, amount, increase);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral\\n  /// is not used to back stables\\n  /// @dev The system may still have a non null balance of the collateral that is revoked: this should later\\n  /// be handled through a recoverERC20 call\\n  /// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is\\n  /// true\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {\\n    LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setOracle(address collateral, bytes memory oracleConfig) external restricted {\\n    LibSetters.setOracle(collateral, oracleConfig);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateOracle(address collateral) external {\\n    if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    LibOracle.updateOracle(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setWhitelistStatus(\\n    address collateral,\\n    uint8 whitelistStatus,\\n    bytes memory whitelistData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external restricted {\\n    LibSetters.updatePayees(_payees, _shares, _skipRelease);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external restricted {\\n    LibSetters.updateSlippageTolerance(collateral, slippageTolerance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {\\n    LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setSwapRouter(address swapRouter) external restricted {\\n    LibSetters.setSwapRouter(swapRouter);\\n  }\\n}\\n\",\"keccak256\":\"0x7c64a27bfb326989b6fdc21b3982ef5ce95aa2a576a4edc6d8334a8820f3b8fb\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport { LibSurplus } from \\\"./LibSurplus.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { LibDiamond } from \\\"./LibDiamond.sol\\\";\\nimport { LibWhitelist } from \\\"./LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibSetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibSetters.sol\\nlibrary LibSetters {\\n  using SafeCast for uint256;\\n\\n  event CollateralAdded(address indexed collateral);\\n  event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);\\n  event CollateralRevoked(address indexed collateral);\\n  event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);\\n  event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);\\n  event OracleSet(address indexed collateral, bytes oracleConfig);\\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n  event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);\\n  event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);\\n  event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);\\n  event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);\\n  event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);\\n  event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);\\n  event PayeeAdded(address indexed payee, uint256 shares);\\n  event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);\\n  event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);\\n  event SwapRouterUpdated(address indexed swapRouter);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GOVERNOR ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `setAccessManager`\\n  function setAccessManager(IAccessManager _newAccessManager) internal {\\n    if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();\\n    DiamondStorage storage ds = s.diamondStorage();\\n    address previousAccessManager = address(ds.accessManager);\\n    ds.accessManager = _newAccessManager;\\n    emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));\\n  }\\n\\n  /// @notice Internal version of `setCollateralManager`\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    internal\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    if (managerData.config.length != 0) {\\n      // The first subCollateral given should be the actual collateral asset\\n      if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();\\n      // Sanity check on the manager data that is passed\\n      LibManager.parseManagerConfig(managerData.config);\\n      collatInfo.isManaged = 1;\\n    } else {\\n      collatInfo.isManaged = 0;\\n    }\\n    collatInfo.managerData = managerData;\\n    emit CollateralManagerSet(collateral, managerData);\\n  }\\n\\n  /// @notice Internal version of `toggleTrusted`\\n  function toggleTrusted(address sender, TrustedType t) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 trustedStatus;\\n    if (t == TrustedType.Updater) {\\n      trustedStatus = 1 - ts.isTrusted[sender];\\n      ts.isTrusted[sender] = trustedStatus;\\n    } else {\\n      trustedStatus = 1 - ts.isSellerTrusted[sender];\\n      ts.isSellerTrusted[sender] = trustedStatus;\\n    }\\n    emit TrustedToggled(sender, trustedStatus == 1, t);\\n  }\\n\\n  /// @notice Internal version of `addCollateral`\\n  function addCollateral(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals != 0) revert AlreadyAdded();\\n    collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());\\n    ts.collateralList.push(collateral);\\n    emit CollateralAdded(collateral);\\n  }\\n\\n  /// @notice Internal version of `adjustStablecoins`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();\\n    if (increase) {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables + normalizedAmount;\\n      if (uint256(collatInfo.normalizedStables) * uint256(ts.normalizer) / BASE_27 > collatInfo.stablecoinCap) {\\n        revert AboveCap();\\n      }\\n    } else {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables - normalizedAmount;\\n    }\\n    emit ReservesAdjusted(collateral, amount, increase);\\n  }\\n\\n  /// @notice Internal version of `revokeCollateral`\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (collatInfo.normalizedStables > 0) revert CollateralBacked();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    delete ts.collaterals[collateral];\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 length = collateralListMem.length;\\n    for (uint256 i; i < length - 1; ++i) {\\n      if (collateralListMem[i] == collateral) {\\n        ts.collateralList[i] = collateralListMem[length - 1];\\n        break;\\n      }\\n    }\\n    ts.collateralList.pop();\\n    emit CollateralRevoked(collateral);\\n  }\\n\\n  /// @notice Internal version of `setOracle`\\n  function setOracle(address collateral, bytes memory oracleConfig) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    (,,,, bytes memory hyperparameters) =\\n      abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    if (userDeviation > burnRatioDeviation) revert InvalidParams();\\n    // Checks oracle validity\\n    LibOracle.readMint(oracleConfig);\\n    collatInfo.oracleConfig = oracleConfig;\\n    emit OracleSet(collateral, oracleConfig);\\n  }\\n\\n  /// @notice Internal version of `setWhitelistStatus`\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {\\n    if (whitelistStatus > 1) revert InvalidWhitelistStatus();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (whitelistStatus == 1) {\\n      // Sanity check\\n      LibWhitelist.checkWhitelist(whitelistData, address(this));\\n      collatInfo.whitelistData = whitelistData;\\n    } else {\\n      // If whitelist is revoked, clear the whitelist data\\n      collatInfo.whitelistData = \\\"\\\";\\n    }\\n    collatInfo.onlyWhitelisted = whitelistStatus;\\n    emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GUARDIAN ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `pause` \\u2014 sets the action's live flag to `0`\\n  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance\\n  /// call cannot pass silently\\n  function pause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 0);\\n  }\\n\\n  /// @notice Internal version of `unpause` \\u2014 sets the action's live flag to `1`\\n  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance\\n  /// call cannot pass silently\\n  function unpause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 1);\\n  }\\n\\n  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`\\n  /// to unpause. Reverts on no-op transitions.\\n  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;\\n      if (currentIsLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      if (action == ActionType.Mint) {\\n        collatInfo.isMintLive = targetIsLive;\\n      } else {\\n        collatInfo.isBurnLive = targetIsLive;\\n      }\\n    } else {\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      if (ts.isRedemptionLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      ts.isRedemptionLive = targetIsLive;\\n    }\\n    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);\\n  }\\n\\n  /// @notice Internal version of `setFees`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);\\n    if (mint) {\\n      collatInfo.xFeeMint = xFee;\\n      collatInfo.yFeeMint = yFee;\\n    } else {\\n      collatInfo.xFeeBurn = xFee;\\n      collatInfo.yFeeBurn = yFee;\\n    }\\n    emit FeesSet(collateral, xFee, yFee, mint);\\n  }\\n\\n  /// @notice Internal version of `setRedemptionCurveParams`\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    LibSetters.checkFees(xFee, yFee, ActionType.Redeem);\\n    ts.xRedemptionCurve = xFee;\\n    ts.yRedemptionCurve = yFee;\\n    emit RedemptionCurveParamsSet(xFee, yFee);\\n  }\\n\\n  /// @notice Internal version of `toggleWhitelist`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];\\n    ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;\\n    emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);\\n  }\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a collateral\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    collatInfo.stablecoinCap = stablecoinCap;\\n    emit StablecoinCapSet(collateral, stablecoinCap);\\n  }\\n\\n  /// @notice Internal version of `updatePayees`\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) internal {\\n    if (_payees.length == 0 || _payees.length > MAX_PAYEES) revert InvalidLengths();\\n    if (_payees.length != _shares.length) revert ArrayLengthMismatch();\\n    /// @dev Distribute the fees before updating the fee receivers.\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!_skipRelease) {\\n      uint256 income = ts.tokenP.balanceOf(address(this));\\n      if (income > 0 && ts.payees.length > 0) {\\n        LibSurplus.release(income, ts.payees);\\n      }\\n    }\\n\\n    // Zero out stale shares for old payees\\n    uint256 i = 0;\\n    for (; i < ts.payees.length; ++i) {\\n      ts.shares[ts.payees[i]] = 0;\\n    }\\n    delete ts.payees;\\n    uint256 _totalShares = 0;\\n    i = 0;\\n    for (; i < _payees.length; ++i) {\\n      for (uint256 j = 0; j < i; ++j) {\\n        if (_payees[j] == _payees[i]) revert AlreadyAdded();\\n      }\\n      _totalShares += _addPayee(_payees[i], _shares[i]);\\n    }\\n    ts.totalShares = _totalShares;\\n  }\\n\\n  /// @notice Internal version of `updateSlippageTolerance`\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) internal {\\n    if (slippageTolerance > BASE_9) revert InvalidRate();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.slippageTolerance[collateral] = slippageTolerance;\\n    emit SlippageToleranceUpdated(collateral, slippageTolerance);\\n  }\\n\\n  /// @notice Internal version of `setSwapRouter`\\n  function setSwapRouter(address swapRouter) internal {\\n    if (swapRouter == address(0)) revert ZeroAddress();\\n    s.transmuterStorage().swapRouter = swapRouter;\\n    emit SwapRouterUpdated(swapRouter);\\n  }\\n\\n  /// @notice Internal version of `updateSurplusBufferRatio`\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {\\n    if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.surplusBufferRatio = _surplusBufferRatio;\\n    emit SurplusBufferRatioUpdated(_surplusBufferRatio);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions\\n  function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {\\n    uint256 n = xFee.length;\\n    if (n != yFee.length || n == 0) revert InvalidParams();\\n    if (\\n      // Mint inflexion points should be in [0,BASE_9[\\n      // We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9\\n      // Hence we consider BASE_12 as the max value (100% fees) for yFeeMint\\n      // Burn inflexion points should be in [0,BASE_9] but fees should be constant in\\n      // the first segment [BASE_9, x_{n-1}[\\n      // Redemption inflexion points should be in [0,BASE_9]\\n      (action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))\\n        || (action == ActionType.Burn\\n          && (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1]))))\\n        || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))\\n    ) {\\n      revert InvalidParams();\\n    }\\n\\n    for (uint256 i; i < n - 1; ++i) {\\n      if (\\n        // xFee strictly increasing and yFee increasing for mints\\n        // xFee strictly decreasing and yFee increasing for burns\\n        // xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions\\n        (action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))\\n      ) revert InvalidParams();\\n    }\\n\\n    // If a mint or burn fee is negative, we need to check that accounts atomically minting\\n    // (from any collateral) and then burning cannot get more than their initial value\\n    if (yFee[0] < 0) {\\n      if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 length = collateralListMem.length;\\n      if (action == ActionType.Mint) {\\n        // This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;\\n          if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n      if (action == ActionType.Burn) {\\n        // This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;\\n          if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n    }\\n  }\\n\\n  /// @notice Add a new fee receiver.\\n  /// @param _payee The address of the fee receiver.\\n  /// @param _shares The number of shares assigned to the fee receiver.\\n  function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {\\n    if (_shares == 0) revert ZeroAmount();\\n    // The Parallelizer holds the income being distributed, so a share allocated to itself is handed\\n    // back to `release` as fresh income on the next call. `address(0)` stays valid: `LibSurplus`\\n    // treats it as the sentinel for burning that share.\\n    if (_payee == address(this)) revert InvalidPayee();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n\\n    ts.payees.push(_payee);\\n    ts.shares[_payee] = _shares;\\n    emit PayeeAdded(_payee, _shares);\\n    return _shares;\\n  }\\n}\\n\",\"keccak256\":\"0x45ed1863aec8d20f3659d2b0ea657b629b5c33b71f895ae6775ea72156203197\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
   },
   "userdoc": {
+    "events": {
+      "OracleTargetUpdated(address,uint256,uint256)": {
+        "notice": "Emitted when a MAX target price is ratcheted up by `updateOracle`"
+      }
+    },
     "kind": "user",
     "methods": {
       "addCollateral(address)": {
@@ -836,6 +906,9 @@
       "setOracle(address,bytes)": {
         "notice": "Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations"
       },
+      "setSwapRouter(address)": {
+        "notice": "Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to"
+      },
       "setWhitelistStatus(address,uint8,bytes)": {
         "notice": "Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist"
       },
@@ -859,13 +932,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0x7cbf40a2699c865662fca63ab183b71e210d058e99bea42c30a22b80480ab61d",
-    "nonce": "0xae",
+    "hash": "0x08ee937fa353757103f8671ba2e41d2589e2cef9912dd537a2712d8620ba9bc0",
+    "nonce": "0xcb",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
     "blockHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
-    "blockNumber": "0x2eb064e",
-    "transactionIndex": "0x1d"
+    "blockNumber": "0x31e6d75",
+    "transactionIndex": "0x48"
   }
 }
\ No newline at end of file

From 4c832f9d660693d64314372fc8841a89c8042e42 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Thu, 15 Oct 2026 14:14:06 +0400
Subject: [PATCH 31/38] chore(deployments): record the mainnet facets upgrade
 and GenericRebalancer

SettersGovernor, Getters, Redeemer and RewardHandler are redeployed, the other
facets already had the current bytecode. The GenericRebalancer is deployed
behind the team CooperAccessManager.
---
 .../mainnet/GenericRebalancer_USDp.json       | 1228 +++++++++++++++++
 deployments/mainnet/Getters.json              |   46 +-
 deployments/mainnet/Redeemer.json             |   71 +-
 deployments/mainnet/RewardHandler.json        |   35 +-
 deployments/mainnet/SettersGovernor.json      |   97 +-
 5 files changed, 1409 insertions(+), 68 deletions(-)
 create mode 100644 deployments/mainnet/GenericRebalancer_USDp.json

diff --git a/deployments/mainnet/GenericRebalancer_USDp.json b/deployments/mainnet/GenericRebalancer_USDp.json
new file mode 100644
index 0000000..bcfd86f
--- /dev/null
+++ b/deployments/mainnet/GenericRebalancer_USDp.json
@@ -0,0 +1,1228 @@
+{
+  "address": "0xa2961be0e3b928288db2d9d80d125c68f0092289",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "initialTokenTransferAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "initialSwapRouter",
+          "type": "address"
+        },
+        {
+          "internalType": "contract ITokenP",
+          "name": "definitivetokenP",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IParallelizer",
+          "name": "definitiveParallelizer",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "initialAuthority",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC3156FlashLender",
+          "name": "definitiveFlashloan",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "authority",
+          "type": "address"
+        }
+      ],
+      "name": "AccessManagedInvalidAuthority",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        },
+        {
+          "internalType": "uint32",
+          "name": "delay",
+          "type": "uint32"
+        }
+      ],
+      "name": "AccessManagedRequiredDelay",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        }
+      ],
+      "name": "AccessManagedUnauthorized",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "InvalidParam",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "NotTrusted",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "NotTrustedOrGuardian",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        }
+      ],
+      "name": "SafeERC20FailedOperation",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "SwapError",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "ZeroAmount",
+      "type": "error"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "AllowanceReset",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "authority",
+          "type": "address"
+        }
+      ],
+      "name": "AuthorityUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "Recovered",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newSwapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "SwapRouterUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newTokenTransferAddress",
+          "type": "address"
+        }
+      ],
+      "name": "TokenTransferAddressUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "trusted",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "bool",
+          "name": "status",
+          "type": "bool"
+        }
+      ],
+      "name": "TrustedToggled",
+      "type": "event"
+    },
+    {
+      "inputs": [],
+      "name": "CALLBACK_SUCCESS",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "addBudget",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "authority",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "budget",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        }
+      ],
+      "name": "computeRebalanceAmount",
+      "outputs": [
+        {
+          "internalType": "uint8",
+          "name": "increase",
+          "type": "uint8"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "flashloan",
+      "outputs": [
+        {
+          "internalType": "contract IERC3156FlashLender",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "scale",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "extraData",
+          "type": "bytes"
+        }
+      ],
+      "name": "harvest",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isConsumingScheduledOp",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "",
+          "type": "bytes4"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "isTrusted",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "initiator",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "fee",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        }
+      ],
+      "name": "onFlashLoan",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "parallelizer",
+      "outputs": [
+        {
+          "internalType": "contract IParallelizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountToRecover",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "recoverERC20",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "removeBudget",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "resetAllowance",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newAuthority",
+          "type": "address"
+        }
+      ],
+      "name": "setAuthority",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "newMaxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "name": "setMaxSlippage",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newSwapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "setSwapRouter",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        }
+      ],
+      "name": "setTargetExposure",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newTokenTransferAddress",
+          "type": "address"
+        }
+      ],
+      "name": "setTokenTransferAddress",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "asset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "minExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "overrideExposures",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "name": "setYieldBearingAssetData",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "swapRouter",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "trusted",
+          "type": "address"
+        }
+      ],
+      "name": "toggleTrusted",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "tokenP",
+      "outputs": [
+        {
+          "internalType": "contract ITokenP",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "tokenTransferAddress",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        }
+      ],
+      "name": "updateLimitExposuresYieldAsset",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "yieldBearingData",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "asset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "minExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "overrideExposures",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "contractName": "GenericRebalancer",
+  "sourceName": "contracts/helpers/GenericRebalancer.sol",
+  "bytecode": "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",
+  "deployedBytecode": "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",
+  "linkReferences": {},
+  "deployedLinkReferences": {},
+  "immutableReferences": {
+    "10252": [
+      {
+        "length": 32,
+        "start": 629
+      },
+      {
+        "length": 32,
+        "start": 1913
+      },
+      {
+        "length": 32,
+        "start": 2055
+      },
+      {
+        "length": 32,
+        "start": 2191
+      },
+      {
+        "length": 32,
+        "start": 4217
+      },
+      {
+        "length": 32,
+        "start": 5920
+      },
+      {
+        "length": 32,
+        "start": 6053
+      },
+      {
+        "length": 32,
+        "start": 6348
+      },
+      {
+        "length": 32,
+        "start": 6493
+      },
+      {
+        "length": 32,
+        "start": 7129
+      },
+      {
+        "length": 32,
+        "start": 7419
+      }
+    ],
+    "10256": [
+      {
+        "length": 32,
+        "start": 470
+      },
+      {
+        "length": 32,
+        "start": 1497
+      },
+      {
+        "length": 32,
+        "start": 1849
+      },
+      {
+        "length": 32,
+        "start": 2137
+      },
+      {
+        "length": 32,
+        "start": 3715
+      },
+      {
+        "length": 32,
+        "start": 6001
+      },
+      {
+        "length": 32,
+        "start": 8074
+      }
+    ],
+    "11053": [
+      {
+        "length": 32,
+        "start": 538
+      },
+      {
+        "length": 32,
+        "start": 1553
+      },
+      {
+        "length": 32,
+        "start": 8026
+      }
+    ]
+  },
+  "inputSourceName": "project/contracts/helpers/GenericRebalancer.sol",
+  "devdoc": {
+    "author": "Cooper Labs",
+    "custom:contact": "security@cooperlabs.xyz",
+    "details": "Generic contract for trusted callers to adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract, substantially modified: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
+    "errors": {
+      "SafeERC20FailedOperation(address)": [
+        {
+          "details": "An operation with an ERC-20 token failed."
+        }
+      ]
+    },
+    "events": {
+      "AuthorityUpdated(address)": {
+        "details": "Authority that manages this contract was updated."
+      }
+    },
+    "kind": "dev",
+    "methods": {
+      "addBudget(uint256,address)": {
+        "params": {
+          "amount": "amount of tokenP to add to the budget",
+          "receiver": "address of the receiver"
+        }
+      },
+      "authority()": {
+        "details": "Returns the current authority."
+      },
+      "computeRebalanceAmount(address)": {
+        "params": {
+          "yieldBearingAsset": "address of the yield bearing asset"
+        },
+        "returns": {
+          "amount": "amount to be rebalanced",
+          "increase": "whether the exposure should be increased"
+        }
+      },
+      "harvest(address,uint256,bytes)": {
+        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippageRestricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the collateral oracle, neither of which can be safely exposed to arbitrary callers"
+      },
+      "isConsumingScheduledOp()": {
+        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
+      },
+      "onFlashLoan(address,address,uint256,uint256,bytes)": {
+        "details": "A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any shortfall between the principal and the tokenP the rebalance minted back",
+        "params": {
+          "amount": "The amount of tokens lent.",
+          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
+          "fee": "The additional amount of tokens to repay.",
+          "initiator": "The initiator of the loan.",
+          "token": "The loan currency."
+        },
+        "returns": {
+          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
+        }
+      },
+      "recoverERC20(address,uint256,address)": {
+        "params": {
+          "amountToRecover": "amount to recover",
+          "to": "address to send the recovered tokens",
+          "tokenAddress": "address of the token to recover"
+        }
+      },
+      "removeBudget(uint256,address)": {
+        "params": {
+          "amount": "amount of tokenP to remove from the budget",
+          "receiver": "address of the receiver"
+        }
+      },
+      "resetAllowance(address,address)": {
+        "details": "Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing asset's configuration revokes the approvals it created, but this covers a spender that became untrusted for any other reason.",
+        "params": {
+          "spender": "address losing the allowance",
+          "token": "address of the token"
+        }
+      },
+      "setAuthority(address)": {
+        "details": "Transfers control to a new authority. The caller must be the current authority."
+      },
+      "setMaxSlippage(address,uint64)": {
+        "params": {
+          "newMaxSlippage": "new max allowed slippage"
+        }
+      },
+      "setSwapRouter(address)": {
+        "params": {
+          "newSwapRouter": "address of the swap router"
+        }
+      },
+      "setTargetExposure(address,uint64)": {
+        "params": {
+          "targetExposure": "target exposure to the yield bearing asset used",
+          "yieldBearingAsset": "address of the yield bearing asset"
+        }
+      },
+      "setTokenTransferAddress(address)": {
+        "params": {
+          "newTokenTransferAddress": "address of the token transfer contract"
+        }
+      },
+      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": {
+        "params": {
+          "asset": "address of the asset",
+          "maxExposure": "maximum exposure within the Parallelizer to the asset",
+          "minExposure": "minimum exposure within the Parallelizer to the asset",
+          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
+          "targetExposure": "target exposure to the yieldBearingAsset asset used",
+          "yieldBearingAsset": "address of the yieldBearingAsset"
+        }
+      },
+      "toggleTrusted(address)": {
+        "params": {
+          "trusted": "address to toggle the trusted status"
+        }
+      },
+      "updateLimitExposuresYieldAsset(address)": {
+        "params": {
+          "yieldBearingAsset": "address of the yield bearing asset"
+        }
+      }
+    },
+    "title": "GenericRebalancer",
+    "version": 1
+  },
+  "evm": {
+    "gasEstimates": {
+      "creation": {
+        "codeDepositCost": "2436200",
+        "executionCost": "infinite",
+        "totalCost": "infinite"
+      },
+      "external": {
+        "CALLBACK_SUCCESS()": "240",
+        "addBudget(uint256,address)": "infinite",
+        "authority()": "2407",
+        "budget(address)": "2554",
+        "computeRebalanceAmount(address)": "infinite",
+        "flashloan()": "infinite",
+        "harvest(address,uint256,bytes)": "infinite",
+        "isConsumingScheduledOp()": "2442",
+        "isTrusted(address)": "2612",
+        "onFlashLoan(address,address,uint256,uint256,bytes)": "infinite",
+        "parallelizer()": "infinite",
+        "recoverERC20(address,uint256,address)": "infinite",
+        "removeBudget(uint256,address)": "infinite",
+        "resetAllowance(address,address)": "infinite",
+        "setAuthority(address)": "30486",
+        "setMaxSlippage(address,uint64)": "infinite",
+        "setSwapRouter(address)": "infinite",
+        "setTargetExposure(address,uint64)": "infinite",
+        "setTokenTransferAddress(address)": "infinite",
+        "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": "infinite",
+        "swapRouter()": "2392",
+        "toggleTrusted(address)": "infinite",
+        "tokenP()": "infinite",
+        "tokenTransferAddress()": "2415",
+        "updateLimitExposuresYieldAsset(address)": "infinite",
+        "yieldBearingData(address)": "5001"
+      },
+      "internal": {
+        "_adjustYieldExposure(uint256,uint8,address,address,uint256,enum SwapType,bytes memory)": "infinite",
+        "_recoverResidualInput(address,uint256)": "infinite",
+        "_swapToTokenOut(uint256,address,address,uint256,enum SwapType,bytes memory)": "infinite",
+        "_swapToTokenOutSwap(address,address,uint256,bytes memory)": "infinite",
+        "_swapToTokenOutVault(uint256,address,address,uint256)": "infinite"
+      }
+    }
+  },
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"AllowanceReset\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"resetAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newMaxSlippage\",\"type\":\"uint64\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxSlippage\",\"type\":\"uint64\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxSlippage\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for trusted callers to adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract, substantially modified: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippageRestricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the collateral oracle, neither of which can be safely exposed to arbitrary callers\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any shortfall between the principal and the tokenP the rebalance minted back\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"resetAllowance(address,address)\":{\"details\":\"Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing asset's configuration revokes the approvals it created, but this covers a spender that became untrusted for any other reason.\",\"params\":{\"spender\":\"address losing the allowance\",\"token\":\"address of the token\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint64)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericRebalancer\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"resetAllowance(address,address)\":{\"notice\":\"Set an allowance this contract granted back to zero\"},\"setMaxSlippage(address,uint64)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/helpers/GenericRebalancer.sol\":\"GenericRebalancer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0x1121e070554cffc6d536f658332a1a3d65fb2ea5573cd774f4ecbd02a2fcf4b7\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x4e4b982b56b50290dd1dcaa2fef1178b1574dfc7c0f0a8ef9cb68a207d72582e\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity >=0.5.0;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x218d708e7d8df417db24a497727eefb7772e61c7cde3886fc42bbcb6aafa6947\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/helpers/BaseRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IRebalancer.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer, bounded below 1e9 so uint64 leaves the\\n  // struct packed in two slots\\n  uint64 maxSlippage;\\n}\\n\\n/// @title BaseRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a rebalancer that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract, substantially modified:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseRebalancer is IRebalancer, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n  event AllowanceReset(address indexed token, address indexed spender);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /**\\n   * @notice Set an allowance this contract granted back to zero\\n   * @param token address of the token\\n   * @param spender address losing the allowance\\n   * @dev Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing\\n   * asset's configuration revokes the approvals it created, but this covers a spender that became\\n   * untrusted for any other reason.\\n   */\\n  function resetAllowance(address token, address spender) external restricted {\\n    IERC20(token).forceApprove(spender, 0);\\n    emit AllowanceReset(token, spender);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    address previousAsset = yieldBearingInfo.asset;\\n    // Allowances are granted without expiry, so the outgoing asset would keep the yield bearing\\n    // vault authorised over any of it later held here\\n    if (previousAsset != address(0) && previousAsset != asset) {\\n      IERC20(previousAsset).forceApprove(yieldBearingAsset, 0);\\n      emit AllowanceReset(previousAsset, yieldBearingAsset);\\n      _revokeAssetAllowances(yieldBearingAsset, previousAsset);\\n    }\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /// @notice Lets a rebalancer revoke the allowances it granted over an asset being rotated out\\n  function _revokeAssetAllowances(address yieldBearingAsset, address previousAsset) internal virtual { }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingData[yieldBearingAsset].maxSlippage = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x5d05479be1ac7d1dc738cb8fc2e539c82e88a2191dee278cc74fd647eed17ebc\",\"license\":\"GPL-3.0\"},\"project/contracts/helpers/GenericRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseRebalancer, YieldBearingParams } from \\\"./BaseRebalancer.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for trusted callers to adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract, substantially modified:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseRebalancer(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  /// @dev Restricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the\\n  /// collateral oracle, neither of which can be safely exposed to arbitrary callers\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual onlyTrusted {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  /// @dev A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any\\n  /// shortfall between the principal and the tokenP the rebalance minted back\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this)) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 tokenInBalanceBefore = IERC20(tokenIn).balanceOf(address(this));\\n\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n    // The principal is spent, what the lender will pull back is the principal plus its fee\\n    amount += fee;\\n\\n    // Swap to tokenOut\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n\\n    amountStableOut += _recoverResidualInput(tokenIn, tokenInBalanceBefore);\\n\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    } else if (amountStableOut > amount) {\\n      budget[sender] += amountStableOut - amount;\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  /**\\n   * @dev Returns any input the route did not consume to the Parallelizer\\n   * @param tokenIn address of the token offered to the route\\n   * @param balanceBefore balance of `tokenIn` held before the operation\\n   * @return the tokenP obtained from the remainder, zero when the route consumed everything\\n   *\\n   * Router calldata is built off chain while the input is sized on chain, so a route can consume\\n   * less than was offered. Returning the remainder keeps it inside the Parallelizer's accounting\\n   * instead of stranding it here, and it settles with the rest of the operation.\\n   */\\n  function _recoverResidualInput(address tokenIn, uint256 balanceBefore) internal returns (uint256) {\\n    uint256 balanceAfter = IERC20(tokenIn).balanceOf(address(this));\\n    if (balanceAfter <= balanceBefore) return 0;\\n    uint256 residual = balanceAfter - balanceBefore;\\n    _adjustAllowance(tokenIn, address(parallelizer), residual);\\n    return parallelizer.swapExactInput(residual, 0, tokenIn, address(tokenP), address(this), block.timestamp);\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n    // A route that consumed less than offered would otherwise leave the difference approved\\n    IERC20(tokenIn).forceApprove(tokenTransferAddress, 0);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0xe10b65b2a75ead0d938a2282cf478e94ea425adb38a03ca077fa0422ec2d322c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  function getSwapRouter() external view returns (address);\\n\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x27a333b02ba124b5964a63bddeb301328197bddbe98538903cd41a8b40900d12\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\nimport { ISurplus } from \\\"./ISurplus.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuter` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuter.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper,\\n  ISurplus\\n{ }\\n\",\"keccak256\":\"0x3d43efebf663185429a411300477c3a62bf5e025fb286cf812cd0b589fb8bd5a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IRebalancer {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0a30a492e29ebe67db0f4cac7bfb142d04556a61282e71733d13c11daeba08b1\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was\\n  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since\\n  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`\\n  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity\\n  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x3362bd4532915b6e2b26b2fdc967a89ea66de5ea5f669d7a621ee69d75c02273\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a call to the configured swap router\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to the swap router\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xb3604f35c5bb44791020588e00774299a6a4adae17d62d1e53cd8be86da6b709\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n\\n  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain\\n  /// specific and must be set on every deployment before rewards can be sold\\n  function setSwapRouter(address swapRouter) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xe62d2880420afb053498b01f1def17d4c8e2c6c9b48cc5a71d013150a5ca8db4\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISurplus.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISurplus {\\n  /// @dev This function will swap the surplus of a collateral for the stable asset link to the protocol.\\n  /// @param collateral The collateral address to process the surplus of.\\n  /// @param maxCollateralAmount The maximum amount of collateral to process. If 0, processes the full surplus.\\n  /// @return collateralSurplus The surplus of the collateral actually processed.\\n  /// @return stableSurplus The surplus amount in stable calculated from the collateral surplus.\\n  /// @return issuedAmount The amount of newly issued stablecoins from the collateral swapped\\n  function processSurplus(\\n    address collateral,\\n    uint256 maxCollateralAmount\\n  )\\n    external\\n    returns (uint256 collateralSurplus, uint256 stableSurplus, uint256 issuedAmount);\\n\\n  /// @notice Releases the income to the payees\\n  /// @return payees The addresses of the payees\\n  /// @return amounts The amounts released to the payees\\n  function release() external returns (address[] memory payees, uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x0129ea80a666d553ddd13c02f56a72cc96a6ac4e45578f0f523def2732ce450f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactInput`, but using a single EIP-3009 authorization for `tokenIn`.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeSwapExactInputNonce(...)`,\\n  /// which binds the full swap intent. `authData.nonce` carries the caller-chosen `userSalt`; the\\n  /// facet recomputes the derived nonce from the call arguments before forwarding it to the\\n  /// token, so any tampering with `to`/slippage/deadline invalidates the signature.\\n  /// @param authData ABI-encoded `AuthorizationParams` with `nonce = userSalt`\\n  function swapExactInputWithAuthorization(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata authData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactOutput`, but using a single EIP-3009 authorization for `tokenIn`.\\n  /// @dev The authorization must be signed for `amountInMax`; the excess is refunded to the\\n  /// authorizer. Derived-nonce scheme as in `swapExactInputWithAuthorization`, using\\n  /// `LibAuthorization.computeSwapExactOutputNonce(...)`.\\n  /// @param authData ABI-encoded `AuthorizationParams` with `nonce = userSalt`\\n  function swapExactOutputWithAuthorization(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata authData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0xbf7e08cff6dd51c222f86976d3526307098b80100c81978a55566043924cfc06\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"},\"project/libs/helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"}},\"version\":1}",
+  "storageLayout": {
+    "storage": [
+      {
+        "astId": 29857,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "_authority",
+        "offset": 0,
+        "slot": "0",
+        "type": "t_address"
+      },
+      {
+        "astId": 29859,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "_consumingSchedule",
+        "offset": 20,
+        "slot": "0",
+        "type": "t_bool"
+      },
+      {
+        "astId": 10262,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "yieldBearingData",
+        "offset": 0,
+        "slot": "1",
+        "type": "t_mapping(t_address,t_struct(YieldBearingParams)10202_storage)"
+      },
+      {
+        "astId": 10267,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "isTrusted",
+        "offset": 0,
+        "slot": "2",
+        "type": "t_mapping(t_address,t_bool)"
+      },
+      {
+        "astId": 30616,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "swapRouter",
+        "offset": 0,
+        "slot": "3",
+        "type": "t_address"
+      },
+      {
+        "astId": 30619,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "tokenTransferAddress",
+        "offset": 0,
+        "slot": "4",
+        "type": "t_address"
+      },
+      {
+        "astId": 11058,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "budget",
+        "offset": 0,
+        "slot": "5",
+        "type": "t_mapping(t_address,t_uint256)"
+      }
+    ],
+    "types": {
+      "t_address": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      },
+      "t_bool": {
+        "encoding": "inplace",
+        "label": "bool",
+        "numberOfBytes": "1"
+      },
+      "t_mapping(t_address,t_bool)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => bool)",
+        "numberOfBytes": "32",
+        "value": "t_bool"
+      },
+      "t_mapping(t_address,t_struct(YieldBearingParams)10202_storage)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => struct YieldBearingParams)",
+        "numberOfBytes": "32",
+        "value": "t_struct(YieldBearingParams)10202_storage"
+      },
+      "t_mapping(t_address,t_uint256)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => uint256)",
+        "numberOfBytes": "32",
+        "value": "t_uint256"
+      },
+      "t_struct(YieldBearingParams)10202_storage": {
+        "encoding": "inplace",
+        "label": "struct YieldBearingParams",
+        "members": [
+          {
+            "astId": 10191,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "asset",
+            "offset": 0,
+            "slot": "0",
+            "type": "t_address"
+          },
+          {
+            "astId": 10193,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "targetExposure",
+            "offset": 20,
+            "slot": "0",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10195,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "maxExposure",
+            "offset": 0,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10197,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "minExposure",
+            "offset": 8,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10199,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "overrideExposures",
+            "offset": 16,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10201,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "maxSlippage",
+            "offset": 24,
+            "slot": "1",
+            "type": "t_uint64"
+          }
+        ],
+        "numberOfBytes": "64"
+      },
+      "t_uint256": {
+        "encoding": "inplace",
+        "label": "uint256",
+        "numberOfBytes": "32"
+      },
+      "t_uint64": {
+        "encoding": "inplace",
+        "label": "uint64",
+        "numberOfBytes": "8"
+      }
+    }
+  },
+  "userdoc": {
+    "events": {
+      "SwapRouterUpdated(address)": {
+        "notice": "Event emitted when the swap router is updated"
+      },
+      "TokenTransferAddressUpdated(address)": {
+        "notice": "Event emitted when the token proxy is updated"
+      }
+    },
+    "kind": "user",
+    "methods": {
+      "addBudget(uint256,address)": {
+        "notice": "Add budget to be spent by the receiver during the flashloan"
+      },
+      "budget(address)": {
+        "notice": "Budget of tokenP available for each users"
+      },
+      "computeRebalanceAmount(address)": {
+        "notice": "Compute the amount needed to rebalance the Parallelizer"
+      },
+      "flashloan()": {
+        "notice": "Parallel stablecoin flashloan contract"
+      },
+      "harvest(address,uint256,bytes)": {
+        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
+      },
+      "isTrusted(address)": {
+        "notice": "trusted addresses that can update target exposure and do others non critical operations"
+      },
+      "parallelizer()": {
+        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
+      },
+      "recoverERC20(address,uint256,address)": {
+        "notice": "Recover ERC20 tokens"
+      },
+      "removeBudget(uint256,address)": {
+        "notice": "Remove budget from the owner and send it to the receiver"
+      },
+      "resetAllowance(address,address)": {
+        "notice": "Set an allowance this contract granted back to zero"
+      },
+      "setMaxSlippage(address,uint64)": {
+        "notice": "Set the max allowed slippage"
+      },
+      "setSwapRouter(address)": {
+        "notice": "Set the swap router"
+      },
+      "setTargetExposure(address,uint64)": {
+        "notice": "Set the target exposure of a yield bearing asset"
+      },
+      "setTokenTransferAddress(address)": {
+        "notice": "Set the token transfer address"
+      },
+      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": {
+        "notice": "Set the yieldBearingAsset data"
+      },
+      "swapRouter()": {
+        "notice": "address of the router/aggregator"
+      },
+      "toggleTrusted(address)": {
+        "notice": "Toggle the trusted status of an address"
+      },
+      "tokenP()": {
+        "notice": "TokenP handled by the `parallelizer` of interest"
+      },
+      "tokenTransferAddress()": {
+        "notice": "address to approve to transfer tokens to"
+      },
+      "updateLimitExposuresYieldAsset(address)": {
+        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
+      },
+      "yieldBearingData(address)": {
+        "notice": "Data associated to a yield bearing asset"
+      }
+    },
+    "version": 1
+  },
+  "argsData": "0x000000000000000000000000cf5540fffcdc3d510b18bfca6d2b9987b0772559000000000000000000000000cf5540fffcdc3d510b18bfca6d2b9987b07725590000000000000000000000009b3a8f7cec208e247d97dee13313690977e244590000000000000000000000006efeddf9269c3683ba516cb0e2124fe335f262a2000000000000000000000000a66814ee197d8334274aaeeb4987c534789a8194000000000000000000000000c9b6279baa19dbb8bcc3250c89caa093aaba0bfc",
+  "transaction": {
+    "hash": "0xa99b25449770d9f07c225e9f2fc30fe7e65bc533db3b04f755b381af56848f52",
+    "nonce": "0x10a",
+    "origin": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02"
+  },
+  "receipt": {
+    "blockHash": "0xb4d5e44cf0acb7335f8354db9f35efbda29eaea4a286c76408efe40945f8643c",
+    "blockNumber": "0x18fbcd5",
+    "transactionIndex": "0x55"
+  }
+}
\ No newline at end of file
diff --git a/deployments/mainnet/Getters.json b/deployments/mainnet/Getters.json
index 68c5226..34c73cc 100644
--- a/deployments/mainnet/Getters.json
+++ b/deployments/mainnet/Getters.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x4e899b0ab9b7a0fd5fc0dd288fab8a581bb40986",
+  "address": "0x5db9553cf9bdfcc78d02f5d5d474ccb2f167bfc7",
   "abi": [
     {
       "inputs": [],
@@ -549,6 +549,19 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "getSwapRouter",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [],
       "name": "getTotalIssued",
@@ -752,8 +765,8 @@
   ],
   "contractName": "Getters",
   "sourceName": "contracts/parallelizer/facets/Getters.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -804,7 +817,7 @@
       "getSlippageTolerance(address)": {
         "details": "Maximum slippage tolerance is 1e9 (100%)"
       },
-      "getSurplusBufferRatio()": {
+      "getSwapRouter()": {
         "details": "Expressed in base 1e9, and always >= 1e9"
       },
       "isConsumingScheduledOp()": {
@@ -823,9 +836,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "3346200",
-        "executionCost": "3721",
-        "totalCost": "3349921"
+        "codeDepositCost": "3358000",
+        "executionCost": "3737",
+        "totalCost": "3361737"
       },
       "external": {
         "accessManager()": "2418",
@@ -847,7 +860,8 @@
         "getShares(address)": "2561",
         "getSlippageTolerance(address)": "2564",
         "getStablecoinCap(address)": "infinite",
-        "getSurplusBufferRatio()": "2356",
+        "getSurplusBufferRatio()": "2334",
+        "getSwapRouter()": "2420",
         "getTotalIssued()": "infinite",
         "getTotalShares()": "2369",
         "isConsumingScheduledOp()": "infinite",
@@ -862,7 +876,7 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SurplusBufferRatioNotSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroSurplusAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"accessManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralBurnFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralDecimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isManaged\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isMintLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isBurnLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"onlyWhitelisted\",\"type\":\"uint8\"},{\"internalType\":\"uint216\",\"name\":\"normalizedStables\",\"type\":\"uint216\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinCap\",\"type\":\"uint256\"}],\"internalType\":\"struct Collateral\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralList\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralMintFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"collatRatio\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralSurplus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"collateralSurplus\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableSurplus\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralWhitelistData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getIssuedByCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stablecoinsFromCollateral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastReleasedAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getManagerData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracle\",\"outputs\":[{\"internalType\":\"enum OracleReadType\",\"name\":\"oracleType\",\"type\":\"uint8\"},{\"internalType\":\"enum OracleReadType\",\"name\":\"targetType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"oracleData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"targetData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hyperparameters\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracleValues\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"mint\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"burn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ratio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minRatio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"redemption\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPayees\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRedemptionFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xRedemptionCurve\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yRedemptionCurve\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"getShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getSlippageTolerance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getStablecoinCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSurplusBufferRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"enum ActionType\",\"name\":\"action\",\"type\":\"uint8\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrustedSeller\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"isValidSelector\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"isWhitelistedCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enum WhitelistType\",\"name\":\"whitelistType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForType\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"There may be duplicates in the info provided by the getters defined hereThis contract is an authorized fork of Angle's `Getters` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}]},\"kind\":\"dev\",\"methods\":{\"getCollateralRatio()\":{\"details\":\"This function may revert and overflow if the collateral ratio is too big due to a too small amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function become economically impossible\"},\"getCollateralSurplus(address)\":{\"params\":{\"collateral\":\"The collateral address to compute the surplus of.\"},\"returns\":{\"collateralSurplus\":\"The collateral surplus amount.\",\"stableSurplus\":\"The surplus in stable amount.\"}},\"getOracle(address)\":{\"returns\":{\"oracleData\":\"Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\",\"oracleType\":\"Type of oracle (Chainlink, external smart contract, ...)\",\"targetData\":\"Extra data needed to read the target price of the asset\",\"targetType\":\"Type passed to read the value of the target price\"}},\"getOracleValues(address)\":{\"details\":\"This function is not optimized for gas consumption as for instance the `burn` value for collateral is computed twice: once in `readBurn` and once in `getBurnOracle`\",\"returns\":{\"burn\":\"Oracle value that will be used for `collateral` for a burn transaction. This value is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\",\"minRatio\":\"Minimum ratio across all collateral assets between a collateral burn price and its target price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn transactions.\",\"mint\":\"Oracle value to be used for a mint transaction with `collateral`\",\"ratio\":\"Ratio, in base `10**18` between the oracle value of the `collateral` and its target price. This value is 10**18 if the oracle is greater than the collateral price\",\"redemption\":\"Oracle value that would be used to price `collateral` when computing the collateral ratio during a redemption\"}},\"getSlippageTolerance(address)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)\"},\"getSurplusBufferRatio()\":{\"details\":\"Expressed in base 1e9, and always >= 1e9\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"isWhitelistedForCollateral(address,address)\":{\"details\":\"This function is non view as it may consult external non view functions from whitelist providers\"},\"isWhitelistedForType(uint8,address)\":{\"details\":\"Note that ultimately whitelisting may depend as well on external providers\"}},\"title\":\"Getters\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"accessManager()\":{\"notice\":\"Returns the address of the `accessManager` contract\"},\"getCollateralBurnFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn for `collateral`\"},\"getCollateralDecimals(address)\":{\"notice\":\"Returns the decimals of a given `collateral`\"},\"getCollateralInfo(address)\":{\"notice\":\"Returns all the info in storage associated to a `collateral`\"},\"getCollateralList()\":{\"notice\":\"Returns the list of collateral assets supported by the system\"},\"getCollateralMintFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint with `collateral`\"},\"getCollateralRatio()\":{\"notice\":\"Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount of stablecoins issued\"},\"getCollateralSurplus(address)\":{\"notice\":\"Computes the surplus of a collateral.\"},\"getCollateralWhitelistData(address)\":{\"notice\":\"Gets the data needed to deal with whitelists for `collateral`\"},\"getIssuedByCollateral(address)\":{\"notice\":\"Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued through Parallelizer\"},\"getLastReleasedAt()\":{\"notice\":\"Returns the last time the income was released to the payees\"},\"getManagerData(address)\":{\"notice\":\"Returns if a collateral is \\\"managed\\\" and the associated manager configuration\"},\"getOracle(address)\":{\"notice\":\"Returns the data used to compute oracle values for `collateral`\"},\"getOracleValues(address)\":{\"notice\":\"Returns the oracle values associated to `collateral`\"},\"getPayees()\":{\"notice\":\"Returns the payees and their shares\"},\"getRedemptionFees()\":{\"notice\":\"Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral ratio when users come to redeem\"},\"getShares(address)\":{\"notice\":\"Returns the shares of a payee\"},\"getSlippageTolerance(address)\":{\"notice\":\"Returns the slippage tolerance for a `collateral` for the surplus\"},\"getStablecoinCap(address)\":{\"notice\":\"Returns the stablecoin cap for `collateral`\"},\"getSurplusBufferRatio()\":{\"notice\":\"Returns the minimum collateral ratio that must hold after surplus processing\"},\"getTotalIssued()\":{\"notice\":\"Returns the total amount of stablecoins issued through Parallelizer\"},\"getTotalShares()\":{\"notice\":\"Returns the total shares of the payees\"},\"isPaused(address,uint8)\":{\"notice\":\"Returns if the associated functionality is paused or not\"},\"isTrusted(address)\":{\"notice\":\"Returns if `sender` is trusted to update normalizers\"},\"isTrustedSeller(address)\":{\"notice\":\"Returns if `sender` is trusted to update sell rewards\"},\"isValidSelector(bytes4)\":{\"notice\":\"Checks whether a given `selector` is actually a valid selector corresponding to a function in one of the facets of the proxy\"},\"isWhitelistedCollateral(address)\":{\"notice\":\"Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForCollateral(address,address)\":{\"notice\":\"Checks whether `sender` can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForType(uint8,address)\":{\"notice\":\"Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\"},\"tokenP()\":{\"notice\":\"Stablecoin minted by parallelizer\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Getters.sol\":\"Getters\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x04f12ddeb53bb3bba9aaf9a93c62a84076cca496642d4d87556b15120b60e07b\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Getters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IGetters } from \\\"contracts/interfaces/IGetters.sol\\\";\\n\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibSurplus } from \\\"../libraries/LibSurplus.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Getters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev There may be duplicates in the info provided by the getters defined here\\n/// @dev This contract is an authorized fork of Angle's `Getters` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\\ncontract Getters is IGetters {\\n  /// @inheritdoc IGetters\\n  function isValidSelector(bytes4 selector) external view returns (bool) {\\n    return s.diamondStorage().selectorInfo[selector].facetAddress != address(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function tokenP() external view returns (ITokenP) {\\n    return s.transmuterStorage().tokenP;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralList() external view returns (address[] memory) {\\n    return s.transmuterStorage().collateralList;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory) {\\n    return s.transmuterStorage().collaterals[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralDecimals(address collateral) external view returns (uint8) {\\n    return s.transmuterStorage().collaterals[collateral].decimals;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralMintFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeMint, int64[] memory yFeeMint)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeMint, collatInfo.yFeeMint);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralBurnFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeBurn, int64[] memory yFeeBurn)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeBurn, collatInfo.yFeeBurn);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getRedemptionFees()\\n    external\\n    view\\n    returns (uint64[] memory xRedemptionCurve, int64[] memory yRedemptionCurve)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (ts.xRedemptionCurve, ts.yRedemptionCurve);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function may revert and overflow if the collateral ratio is too big due to a too small\\n  /// amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non\\n  /// negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function\\n  /// become economically impossible\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n\\n    (collatRatio, stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    return (\\n      (uint256(ts.collaterals[collateral].normalizedStables) * _normalizer) / BASE_27,\\n      (uint256(ts.normalizedStables) * _normalizer) / BASE_27\\n    );\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalIssued() external view returns (uint256) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (uint256(ts.normalizedStables) * uint256(ts.normalizer)) / BASE_27;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getManagerData(address collateral) external view returns (bool, IERC20[] memory, bytes memory) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      return (true, collatInfo.managerData.subCollaterals, collatInfo.managerData.config);\\n    }\\n    return (false, new IERC20[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is not optimized for gas consumption as for instance the `burn` value for collateral\\n  /// is computed twice: once in `readBurn` and once in `getBurnOracle`\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption)\\n  {\\n    bytes memory oracleConfig = s.transmuterStorage().collaterals[collateral].oracleConfig;\\n    (burn, ratio) = LibOracle.readBurn(oracleConfig);\\n    (minRatio,) = LibOracle.getBurnOracle(collateral, oracleConfig);\\n    return (LibOracle.readMint(oracleConfig), burn, ratio, minRatio, LibOracle.readRedemption(oracleConfig));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    )\\n  {\\n    return LibOracle.getOracle(collateral);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isPaused(address collateral, ActionType action) external view returns (bool) {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      if (action == ActionType.Mint) {\\n        return collatInfo.isMintLive == 0;\\n      } else {\\n        return collatInfo.isBurnLive == 0;\\n      }\\n    } else {\\n      return s.transmuterStorage().isRedemptionLive == 0;\\n    }\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrusted(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrustedSeller(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isSellerTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool) {\\n    return s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is non view as it may consult external non view functions from whitelist providers\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.onlyWhitelisted == 0 || LibWhitelist.checkWhitelist(collatInfo.whitelistData, sender));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedCollateral(address collateral) external view returns (bool) {\\n    return s.transmuterStorage().collaterals[collateral].onlyWhitelisted == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory) {\\n    return s.transmuterStorage().collaterals[collateral].whitelistData;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getStablecoinCap(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().collaterals[collateral].stablecoinCap;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function accessManager() external view returns (address) {\\n    return address(s.diamondStorage().accessManager);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isConsumingScheduledOp() external view returns (bytes4) {\\n    return s.transmuterStorage().consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getPayees() external view returns (address[] memory, uint256[] memory) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory payees = new address[](ts.payees.length);\\n    uint256[] memory shares = new uint256[](ts.payees.length);\\n    for (uint256 i = 0; i < ts.payees.length; i++) {\\n      payees[i] = ts.payees[i];\\n      shares[i] = ts.shares[ts.payees[i]];\\n    }\\n    return (payees, shares);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalShares() external view returns (uint256) {\\n    return s.transmuterStorage().totalShares;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getShares(address payee) external view returns (uint256) {\\n    return s.transmuterStorage().shares[payee];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSlippageTolerance(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().slippageTolerance[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSurplusBufferRatio() external view returns (uint64) {\\n    return s.transmuterStorage().surplusBufferRatio;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getLastReleasedAt() external view returns (uint256) {\\n    return s.transmuterStorage().lastReleasedAt;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    return LibSurplus._computeCollateralSurplus(collateral);\\n  }\\n}\\n\",\"keccak256\":\"0xd53f1dc85e3e3b30205017bf00b54c9b511963034d382ecc647e65ad854b314e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SurplusBufferRatioNotSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroSurplusAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"accessManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralBurnFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralDecimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isManaged\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isMintLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isBurnLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"onlyWhitelisted\",\"type\":\"uint8\"},{\"internalType\":\"uint216\",\"name\":\"normalizedStables\",\"type\":\"uint216\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinCap\",\"type\":\"uint256\"}],\"internalType\":\"struct Collateral\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralList\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralMintFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"collatRatio\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralSurplus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"collateralSurplus\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableSurplus\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralWhitelistData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getIssuedByCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stablecoinsFromCollateral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastReleasedAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getManagerData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracle\",\"outputs\":[{\"internalType\":\"enum OracleReadType\",\"name\":\"oracleType\",\"type\":\"uint8\"},{\"internalType\":\"enum OracleReadType\",\"name\":\"targetType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"oracleData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"targetData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hyperparameters\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracleValues\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"mint\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"burn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ratio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minRatio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"redemption\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPayees\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRedemptionFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xRedemptionCurve\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yRedemptionCurve\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"getShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getSlippageTolerance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getStablecoinCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSurplusBufferRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSwapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"enum ActionType\",\"name\":\"action\",\"type\":\"uint8\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrustedSeller\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"isValidSelector\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"isWhitelistedCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enum WhitelistType\",\"name\":\"whitelistType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForType\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"There may be duplicates in the info provided by the getters defined hereThis contract is an authorized fork of Angle's `Getters` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}]},\"kind\":\"dev\",\"methods\":{\"getCollateralRatio()\":{\"details\":\"This function may revert and overflow if the collateral ratio is too big due to a too small amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function become economically impossible\"},\"getCollateralSurplus(address)\":{\"params\":{\"collateral\":\"The collateral address to compute the surplus of.\"},\"returns\":{\"collateralSurplus\":\"The collateral surplus amount.\",\"stableSurplus\":\"The surplus in stable amount.\"}},\"getOracle(address)\":{\"returns\":{\"oracleData\":\"Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\",\"oracleType\":\"Type of oracle (Chainlink, external smart contract, ...)\",\"targetData\":\"Extra data needed to read the target price of the asset\",\"targetType\":\"Type passed to read the value of the target price\"}},\"getOracleValues(address)\":{\"details\":\"This function is not optimized for gas consumption as for instance the `burn` value for collateral is computed twice: once in `readBurn` and once in `getBurnOracle`\",\"returns\":{\"burn\":\"Oracle value that will be used for `collateral` for a burn transaction. This value is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\",\"minRatio\":\"Minimum ratio across all collateral assets between a collateral burn price and its target price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn transactions.\",\"mint\":\"Oracle value to be used for a mint transaction with `collateral`\",\"ratio\":\"Ratio, in base `10**18` between the oracle value of the `collateral` and its target price. This value is 10**18 if the oracle is greater than the collateral price\",\"redemption\":\"Oracle value that would be used to price `collateral` when computing the collateral ratio during a redemption\"}},\"getSlippageTolerance(address)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)\"},\"getSwapRouter()\":{\"details\":\"Expressed in base 1e9, and always >= 1e9\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"isWhitelistedForCollateral(address,address)\":{\"details\":\"This function is non view as it may consult external non view functions from whitelist providers\"},\"isWhitelistedForType(uint8,address)\":{\"details\":\"Note that ultimately whitelisting may depend as well on external providers\"}},\"title\":\"Getters\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"accessManager()\":{\"notice\":\"Returns the address of the `accessManager` contract\"},\"getCollateralBurnFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn for `collateral`\"},\"getCollateralDecimals(address)\":{\"notice\":\"Returns the decimals of a given `collateral`\"},\"getCollateralInfo(address)\":{\"notice\":\"Returns all the info in storage associated to a `collateral`\"},\"getCollateralList()\":{\"notice\":\"Returns the list of collateral assets supported by the system\"},\"getCollateralMintFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint with `collateral`\"},\"getCollateralRatio()\":{\"notice\":\"Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount of stablecoins issued\"},\"getCollateralSurplus(address)\":{\"notice\":\"Computes the surplus of a collateral.\"},\"getCollateralWhitelistData(address)\":{\"notice\":\"Gets the data needed to deal with whitelists for `collateral`\"},\"getIssuedByCollateral(address)\":{\"notice\":\"Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued through Parallelizer\"},\"getLastReleasedAt()\":{\"notice\":\"Returns the last time the income was released to the payees\"},\"getManagerData(address)\":{\"notice\":\"Returns if a collateral is \\\"managed\\\" and the associated manager configuration\"},\"getOracle(address)\":{\"notice\":\"Returns the data used to compute oracle values for `collateral`\"},\"getOracleValues(address)\":{\"notice\":\"Returns the oracle values associated to `collateral`\"},\"getPayees()\":{\"notice\":\"Returns the payees and their shares\"},\"getRedemptionFees()\":{\"notice\":\"Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral ratio when users come to redeem\"},\"getShares(address)\":{\"notice\":\"Returns the shares of a payee\"},\"getSlippageTolerance(address)\":{\"notice\":\"Returns the slippage tolerance for a `collateral` for the surplus\"},\"getStablecoinCap(address)\":{\"notice\":\"Returns the stablecoin cap for `collateral`\"},\"getSwapRouter()\":{\"notice\":\"Returns the minimum collateral ratio that must hold after surplus processingReturns the aggregator or DEX the `RewardHandler` forwards its swap payload to\"},\"getTotalIssued()\":{\"notice\":\"Returns the total amount of stablecoins issued through Parallelizer\"},\"getTotalShares()\":{\"notice\":\"Returns the total shares of the payees\"},\"isPaused(address,uint8)\":{\"notice\":\"Returns if the associated functionality is paused or not\"},\"isTrusted(address)\":{\"notice\":\"Returns if `sender` is trusted to update normalizers\"},\"isTrustedSeller(address)\":{\"notice\":\"Returns if `sender` is trusted to update sell rewards\"},\"isValidSelector(bytes4)\":{\"notice\":\"Checks whether a given `selector` is actually a valid selector corresponding to a function in one of the facets of the proxy\"},\"isWhitelistedCollateral(address)\":{\"notice\":\"Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForCollateral(address,address)\":{\"notice\":\"Checks whether `sender` can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForType(uint8,address)\":{\"notice\":\"Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\"},\"tokenP()\":{\"notice\":\"Stablecoin minted by parallelizer\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Getters.sol\":\"Getters\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  function getSwapRouter() external view returns (address);\\n\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x27a333b02ba124b5964a63bddeb301328197bddbe98538903cd41a8b40900d12\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Getters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IGetters } from \\\"contracts/interfaces/IGetters.sol\\\";\\n\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibSurplus } from \\\"../libraries/LibSurplus.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Getters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev There may be duplicates in the info provided by the getters defined here\\n/// @dev This contract is an authorized fork of Angle's `Getters` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\\ncontract Getters is IGetters {\\n  /// @inheritdoc IGetters\\n  function isValidSelector(bytes4 selector) external view returns (bool) {\\n    return s.diamondStorage().selectorInfo[selector].facetAddress != address(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function tokenP() external view returns (ITokenP) {\\n    return s.transmuterStorage().tokenP;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralList() external view returns (address[] memory) {\\n    return s.transmuterStorage().collateralList;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory) {\\n    return s.transmuterStorage().collaterals[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralDecimals(address collateral) external view returns (uint8) {\\n    return s.transmuterStorage().collaterals[collateral].decimals;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralMintFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeMint, int64[] memory yFeeMint)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeMint, collatInfo.yFeeMint);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralBurnFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeBurn, int64[] memory yFeeBurn)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeBurn, collatInfo.yFeeBurn);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getRedemptionFees()\\n    external\\n    view\\n    returns (uint64[] memory xRedemptionCurve, int64[] memory yRedemptionCurve)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (ts.xRedemptionCurve, ts.yRedemptionCurve);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function may revert and overflow if the collateral ratio is too big due to a too small\\n  /// amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non\\n  /// negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function\\n  /// become economically impossible\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n\\n    (collatRatio, stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    return (\\n      (uint256(ts.collaterals[collateral].normalizedStables) * _normalizer) / BASE_27,\\n      (uint256(ts.normalizedStables) * _normalizer) / BASE_27\\n    );\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalIssued() external view returns (uint256) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (uint256(ts.normalizedStables) * uint256(ts.normalizer)) / BASE_27;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getManagerData(address collateral) external view returns (bool, IERC20[] memory, bytes memory) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      return (true, collatInfo.managerData.subCollaterals, collatInfo.managerData.config);\\n    }\\n    return (false, new IERC20[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is not optimized for gas consumption as for instance the `burn` value for collateral\\n  /// is computed twice: once in `readBurn` and once in `getBurnOracle`\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption)\\n  {\\n    bytes memory oracleConfig = s.transmuterStorage().collaterals[collateral].oracleConfig;\\n    (burn, ratio) = LibOracle.readBurn(oracleConfig);\\n    (minRatio,) = LibOracle.getBurnOracle(collateral, oracleConfig);\\n    return (LibOracle.readMint(oracleConfig), burn, ratio, minRatio, LibOracle.readRedemption(oracleConfig));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    )\\n  {\\n    return LibOracle.getOracle(collateral);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isPaused(address collateral, ActionType action) external view returns (bool) {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      if (action == ActionType.Mint) {\\n        return collatInfo.isMintLive == 0;\\n      } else {\\n        return collatInfo.isBurnLive == 0;\\n      }\\n    } else {\\n      return s.transmuterStorage().isRedemptionLive == 0;\\n    }\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrusted(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrustedSeller(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isSellerTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool) {\\n    return s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is non view as it may consult external non view functions from whitelist providers\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.onlyWhitelisted == 0 || LibWhitelist.checkWhitelist(collatInfo.whitelistData, sender));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedCollateral(address collateral) external view returns (bool) {\\n    return s.transmuterStorage().collaterals[collateral].onlyWhitelisted == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory) {\\n    return s.transmuterStorage().collaterals[collateral].whitelistData;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getStablecoinCap(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().collaterals[collateral].stablecoinCap;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function accessManager() external view returns (address) {\\n    return address(s.diamondStorage().accessManager);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isConsumingScheduledOp() external view returns (bytes4) {\\n    return s.transmuterStorage().consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getPayees() external view returns (address[] memory, uint256[] memory) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory payees = new address[](ts.payees.length);\\n    uint256[] memory shares = new uint256[](ts.payees.length);\\n    for (uint256 i = 0; i < ts.payees.length; i++) {\\n      payees[i] = ts.payees[i];\\n      shares[i] = ts.shares[ts.payees[i]];\\n    }\\n    return (payees, shares);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalShares() external view returns (uint256) {\\n    return s.transmuterStorage().totalShares;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getShares(address payee) external view returns (uint256) {\\n    return s.transmuterStorage().shares[payee];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSlippageTolerance(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().slippageTolerance[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSwapRouter() external view returns (address) {\\n    return s.transmuterStorage().swapRouter;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSurplusBufferRatio() external view returns (uint64) {\\n    return s.transmuterStorage().surplusBufferRatio;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getLastReleasedAt() external view returns (uint256) {\\n    return s.transmuterStorage().lastReleasedAt;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    return LibSurplus._computeCollateralSurplus(collateral);\\n  }\\n}\\n\",\"keccak256\":\"0x7698420203383c245b91740b40652708e240877ec9d006d211556c7ffe0406e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -927,8 +941,8 @@
       "getStablecoinCap(address)": {
         "notice": "Returns the stablecoin cap for `collateral`"
       },
-      "getSurplusBufferRatio()": {
-        "notice": "Returns the minimum collateral ratio that must hold after surplus processing"
+      "getSwapRouter()": {
+        "notice": "Returns the minimum collateral ratio that must hold after surplus processingReturns the aggregator or DEX the `RewardHandler` forwards its swap payload to"
       },
       "getTotalIssued()": {
         "notice": "Returns the total amount of stablecoins issued through Parallelizer"
@@ -965,13 +979,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0xdc4b816f0a64ae9d9b1ab19a9471f1dd955c77f492c1e7197d11ead187fe9a77",
-    "nonce": "0xe5",
+    "hash": "0x58d8ea980d591440f4131e394a6268145ee16f93b483b334ae49eed0333c2dd7",
+    "nonce": "0x107",
     "origin": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02"
   },
   "receipt": {
-    "blockHash": "0x7a2290cb901673b6de6d10de2a15dc3d1270745b1377e95cc0b3b8141465f410",
-    "blockNumber": "0x186a79c",
-    "transactionIndex": "0x12"
+    "blockHash": "0x07c664c260caadecbdd0dbbd62738e21921ddc9145c2f871554e9dd344f63ea3",
+    "blockNumber": "0x18ef45f",
+    "transactionIndex": "0x10"
   }
 }
\ No newline at end of file
diff --git a/deployments/mainnet/Redeemer.json b/deployments/mainnet/Redeemer.json
index 2d0a18e..4629727 100644
--- a/deployments/mainnet/Redeemer.json
+++ b/deployments/mainnet/Redeemer.json
@@ -1,5 +1,5 @@
 {
-  "address": "0xb049d96b8fedd3eb8ec767b7a33bf95d3be128d0",
+  "address": "0x3607e2f9fca2f18a9a13225e61b68af7f9f8bc5c",
   "abi": [
     {
       "inputs": [],
@@ -78,6 +78,11 @@
       "name": "TooSmallAmountOut",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "UnexpectedRedemptionTokens",
+      "type": "error"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -179,6 +184,11 @@
           "internalType": "uint256[]",
           "name": "minAmountOuts",
           "type": "uint256[]"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
         }
       ],
       "name": "redeem",
@@ -224,6 +234,11 @@
           "name": "forfeitTokens",
           "type": "address[]"
         },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
+        },
         {
           "internalType": "bytes",
           "name": "authData",
@@ -272,6 +287,11 @@
           "internalType": "address[]",
           "name": "forfeitTokens",
           "type": "address[]"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
         }
       ],
       "name": "redeemWithForfeit",
@@ -317,8 +337,8 @@
   ],
   "contractName": "Redeemer",
   "sourceName": "contracts/parallelizer/facets/Redeemer.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -347,10 +367,11 @@
           "tokens": "List of tokens that would be given"
         }
       },
-      "redeem(uint256,address,uint256,uint256[])": {
+      "redeem(uint256,address,uint256,uint256[],bytes32)": {
         "details": "The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function",
         "params": {
           "deadline": "Timestamp before which the redemption should have occured",
+          "expectedTokensHash": "`keccak256(abi.encodePacked(tokens))` over the output list the caller was quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since `minAmountOuts` is positional and a collateral rotation can change which token each entry protects",
           "minAmountOuts": "Minimum amount of each token given back in the redemption to obtain",
           "receiver": "Address which should be receiving the output tokens"
         },
@@ -359,10 +380,10 @@
           "tokens": "List of tokens returned"
         }
       },
-      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": {
-        "details": "The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`."
+      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": {
+        "details": "The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.`expectedTokensHash` matters most here: a signature stays executable for its whole validity window, so without it a relayer could hold one until a collateral rotation reshuffles the output list"
       },
-      "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": {
+      "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": {
         "details": "Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount"
       },
       "updateNormalizer(uint256,bool)": {
@@ -375,28 +396,28 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "2988000",
-        "executionCost": "3276",
-        "totalCost": "2991276"
+        "codeDepositCost": "3024800",
+        "executionCost": "3323",
+        "totalCost": "3028123"
       },
       "external": {
         "quoteRedemptionCurve(uint256)": "infinite",
-        "redeem(uint256,address,uint256,uint256[])": "infinite",
-        "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": "infinite",
-        "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": "infinite",
+        "redeem(uint256,address,uint256,uint256[],bytes32)": "infinite",
+        "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": "infinite",
+        "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": "infinite",
         "updateNormalizer(uint256,bool)": "infinite"
       },
       "internal": {
-        "_consumeAuthAndBurn(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_consumeAuthAndBurn(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_distributeRedemption(struct Redeemer.RedemptionExecution memory)": "infinite",
-        "_executeAuthorization(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_executeAuthorization(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_quoteRedemptionCurve(uint256)": "infinite",
-        "_redeem(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_redeem(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_updateNormalizer(uint256,bool)": "infinite"
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"CannotBurnAllStableIssued\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotWhitelisted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNormalizerValue\",\"type\":\"uint256\"}],\"name\":\"NormalizerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Redeemed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"quoteRedemptionCurve\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"}],\"name\":\"redeem\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"authData\",\"type\":\"bytes\"}],\"name\":\"redeemWithAuthorization\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"}],\"name\":\"redeemWithForfeit\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"updateNormalizer\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `Redeemer` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"returns\":{\"amounts\":\"Amount that would be obtained for each token in the `tokens` array\",\"tokens\":\"List of tokens that would be given\"}},\"redeem(uint256,address,uint256,uint256[])\":{\"details\":\"The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function\",\"params\":{\"deadline\":\"Timestamp before which the redemption should have occured\",\"minAmountOuts\":\"Minimum amount of each token given back in the redemption to obtain\",\"receiver\":\"Address which should be receiving the output tokens\"},\"returns\":{\"amounts\":\"Amount given for each token in the `tokens` array\",\"tokens\":\"List of tokens returned\"}},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)\":{\"details\":\"The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[])\":{\"details\":\"Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount\"},\"updateNormalizer(uint256,bool)\":{\"details\":\"This function may be called by trusted addresses: these could be for instance savings contract minting stablecoins when they notice a profit\"}},\"title\":\"Redeemer\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"notice\":\"Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\"},\"redeem(uint256,address,uint256,uint256[])\":{\"notice\":\"Redeems `amount` of stablecoins from the system\"},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)\":{\"notice\":\"Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[])\":{\"notice\":\"Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`.\"},\"updateNormalizer(uint256,bool)\":{\"notice\":\"Updates the normalizer variable by `amount`\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Redeemer.sol\":\"Redeemer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the\\n  /// signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x2ea4d5ebd3dd0e83071ebedb2c269f501f37033ddce9a1ee9ec40cfde0adfc7a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IEIP3009.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IEIP3009\\n/// @notice Interface for EIP-3009: Transfer With Authorization\\ninterface IEIP3009 {\\n  /// @notice Execute a transfer with a signed authorization (EOA signature)\\n  /// @dev SECURITY: anyone may submit this call (no `msg.sender` restriction). Integrators that\\n  /// pair the transfer with downstream logic (e.g. swap, deposit, redeem) MUST use\\n  /// `receiveWithAuthorization` instead: a mempool watcher can otherwise frontrun the original\\n  /// transaction with a raw `transferWithAuthorization`, burning the nonce so the original\\n  /// reverts while the funds still move - causing the post-transfer logic to be skipped.\\n  /// Use this primitive only for direct payouts to a passive recipient (`msg.sender != to`).\\n  /// @param from The address of the sender\\n  /// @param to The address of the recipient\\n  /// @param value The amount of tokens to transfer\\n  /// @param validAfter The timestamp after which the authorization is valid\\n  /// @param validBefore The timestamp before which the authorization is valid\\n  /// @param nonce The nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Execute a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev SECURITY: see the EOA overload - this primitive is frontrun-prone and must not be used\\n  /// when the transfer is bound to follow-on logic. Use `receiveWithAuthorization` in that case.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EOA signature)\\n  /// @dev The caller must be the payee (`to` address). This has an additional check to ensure\\n  /// that the payee's address matches the caller of this function to prevent front-running attacks.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev The caller must be the payee (`to` address)\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Attempt to cancel an authorization\\n  /// @dev Works only if the authorization is not yet used.\\n  /// EOA wallet signatures should be packed in the order of r, s, v.\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external;\\n\\n  /// @notice Cancel an authorization (EIP-1271 compatible)\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external;\\n\\n  /// @notice Returns the state of an authorization\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @return true if the nonce is used\\n  function authorizationState(address authorizer, bytes32 nonce) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe34cfb584a925054c2e3569c4401c619cd2b928a7b9da04537e71a9089edf55a\",\"license\":\"MIT\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Redeemer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IRedeemer } from \\\"contracts/interfaces/IRedeemer.sol\\\";\\nimport { IEIP3009 } from \\\"contracts/interfaces/external/IEIP3009.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\nimport { LibAuthorization } from \\\"../libraries/LibAuthorization.sol\\\";\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Redeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `Redeemer` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\\ncontract Redeemer is IRedeemer, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  event Redeemed(\\n    uint256 amount,\\n    address[] tokens,\\n    uint256[] amounts,\\n    address[] forfeitTokens,\\n    address indexed from,\\n    address indexed to\\n  );\\n  event NormalizerUpdated(uint256 newNormalizerValue);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev The `minAmountOuts` list must reflect the amount of `tokens` returned\\n  /// @dev In normal conditions, the amount of tokens outputted by this function should be the amount\\n  /// of collateral assets supported by the system, following their order in the `collateralList`.\\n  /// @dev If one collateral has its liquidity managed through strategies, then it's possible that this asset\\n  /// has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption\\n  /// process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral\\n  /// assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering\\n  /// of the token list will be as follows:\\n  /// `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`\\n  /// @dev The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained\\n  /// by calling the `quoteRedemptionCurve` function\\n  /// @dev Tokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the\\n  /// whitelist, otherwise this function reverts\\n  /// @dev No approval is needed before calling this function\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token\\n  /// even if it has enough immediately available to send the amount\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, authData);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev This function may be called by trusted addresses: these could be for instance savings contract\\n  /// minting stablecoins when they notice a profit\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256) {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && s.transmuterStorage().isTrusted[msg.sender] == 0) {\\n      revert NotTrusted();\\n    }\\n    return _updateNormalizer(amount, increase);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    (tokens, amounts,) = _quoteRedemptionCurve(amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Working set passed by reference between `_redeem` and its loop helper, so the call\\n  /// site stays under the EVM stack-depth limit when compiling without via-IR.\\n  struct RedemptionExecution {\\n    uint256 amount;\\n    address from;\\n    address to;\\n    address[] tokens;\\n    uint256[] amounts;\\n    uint256[] subCollateralsTracker;\\n    uint256[] minAmountOuts;\\n    address[] forfeitTokens;\\n  }\\n\\n  /// @notice Internal function of the `redeem` function in the `Redeemer` contract\\n  function _redeem(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    nonReentrant\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    if (s.transmuterStorage().isRedemptionLive == 0) revert Paused();\\n    if (block.timestamp > deadline) revert TooLate();\\n\\n    RedemptionExecution memory redemption;\\n    redemption.amount = amount;\\n    redemption.to = to;\\n    redemption.minAmountOuts = minAmountOuts;\\n    redemption.forfeitTokens = forfeitTokens;\\n\\n    (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);\\n    if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();\\n    _updateNormalizer(amount, false);\\n\\n    redemption.from = _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, authData);\\n\\n    _distributeRedemption(redemption);\\n    emit Redeemed(\\n      redemption.amount,\\n      redemption.tokens,\\n      redemption.amounts,\\n      redemption.forfeitTokens,\\n      redemption.from,\\n      redemption.to\\n    );\\n    return (redemption.tokens, redemption.amounts);\\n  }\\n\\n  /// @notice Releases each non-forfeited collateral output to `redemption.to`. Extracted from `_redeem`\\n  /// so the parent function stays within the EVM stack-depth limit.\\n  function _distributeRedemption(RedemptionExecution memory redemption) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 indexCollateral;\\n    uint256 amountsLength = redemption.amounts.length;\\n    for (uint256 i; i < amountsLength; ++i) {\\n      if (redemption.amounts[i] < redemption.minAmountOuts[i]) revert TooSmallAmountOut();\\n      // If a token is in the `forfeitTokens` list, then it is not sent as part of the redemption process\\n      if (redemption.amounts[i] > 0 && LibHelpers.checkList(redemption.tokens[i], redemption.forfeitTokens) < 0) {\\n        Collateral storage collatInfo = ts.collaterals[collateralListMem[indexCollateral]];\\n        if (collatInfo.onlyWhitelisted > 0 && !LibWhitelist.checkWhitelist(collatInfo.whitelistData, redemption.to)) {\\n          revert NotWhitelisted();\\n        }\\n        if (collatInfo.isManaged > 0) {\\n          LibManager.release(\\n            redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config\\n          );\\n        } else {\\n          IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);\\n        }\\n      }\\n      if (redemption.subCollateralsTracker[indexCollateral] - 1 <= i) ++indexCollateral;\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer (auth flow) or burns directly from\\n  /// `msg.sender`, and returns the address to attribute the `Redeemed` event to.\\n  function _consumeAuthAndBurn(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    ITokenP tokenP = s.transmuterStorage().tokenP;\\n    if (authData.length > 0) {\\n      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, authData);\\n      tokenP.burnSelf(amount, address(this));\\n    } else {\\n      from = msg.sender;\\n      tokenP.burnSelf(amount, msg.sender);\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer via EIP-3009 `receiveWithAuthorization`,\\n  /// using a derived nonce that binds the full redemption intent.\\n  /// @return from The authorizer address (`params.from`), to attribute the redeem event to\\n  function _executeAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));\\n    if (params.value != amount) revert InvalidSwap();\\n    bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(\\n      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, params.nonce\\n    );\\n    IEIP3009(address(s.transmuterStorage().tokenP)).receiveWithAuthorization(\\n      params.from,\\n      address(this),\\n      params.value,\\n      params.validAfter,\\n      params.validBefore,\\n      derivedNonce,\\n      params.signature\\n    );\\n    return params.from;\\n  }\\n\\n  /// @dev This function reverts if `stablecoinsIssued==0`, which is expected behavior as there is nothing to redeem\\n  /// anyway in this case, or if the `amountBurnt` is greater than `stablecoinsIssued`\\n  /// @dev Invariant: `penaltyFactor` is evaluated once at the entry-time `collatRatio` and applied uniformly to the\\n  /// full `amountBurnt`. The curve is not path-integrated, so a single redemption that traverses into a lower-penalty\\n  /// segment still pays the entry-time rate on every unit burned. Splitting the same redemption into smaller calls\\n  /// can yield a strictly better blended rate when the path crosses an ascending segment of the curve. This is a\\n  /// deliberate design choice consistent with penalizing early redemptions during under-collateralization; the gap\\n  /// between single-call and path-integrated pricing scales with the ascending-segment slope and should be\\n  /// considered when calibrating `xRedemptionCurve`/`yRedemptionCurve`.\\n  function _quoteRedemptionCurve(uint256 amountBurnt)\\n    internal\\n    view\\n    returns (address[] memory tokens, uint256[] memory balances, uint256[] memory subCollateralsTracker)\\n  {\\n    uint64 collatRatio;\\n    uint256 stablecoinsIssued;\\n    (collatRatio, stablecoinsIssued, tokens, balances, subCollateralsTracker) = LibGetters.getCollateralRatio();\\n    if (amountBurnt >= stablecoinsIssued) revert CannotBurnAllStableIssued();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    int64[] memory yRedemptionCurveMem = ts.yRedemptionCurve;\\n    uint64 penaltyFactor;\\n    // If the protocol is under-collateralized, a penalty factor is applied to the returned amount of each asset\\n    if (collatRatio < BASE_9) {\\n      uint64[] memory xRedemptionCurveMem = ts.xRedemptionCurve;\\n      penaltyFactor = uint64(LibHelpers.piecewiseLinear(collatRatio, xRedemptionCurveMem, yRedemptionCurveMem));\\n    }\\n\\n    for (uint256 i; i < balances.length; ++i) {\\n      // The amount given for each token in reserves does not depend on the price of the tokens in reserve:\\n      // it is a proportion of the balance for each token computed as the ratio between the stablecoins\\n      // burnt relative to the amount of stablecoins issued.\\n      // If the protocol is over-collateralized, the amount of each token given is inversely proportional\\n      // to the collateral ratio.\\n      balances[i] = collatRatio >= BASE_9\\n        ? (amountBurnt * balances[i] * (uint64(yRedemptionCurveMem[yRedemptionCurveMem.length - 1])))\\n          / (stablecoinsIssued * collatRatio)\\n        : (amountBurnt * balances[i] * penaltyFactor) / (stablecoinsIssued * BASE_9);\\n    }\\n  }\\n\\n  /// @notice Updates the `normalizer` variable used to track stablecoins issued from each asset and globally\\n  function _updateNormalizer(uint256 amount, bool increase) internal returns (uint256 newNormalizerValue) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    uint256 _normalizedStables = ts.normalizedStables;\\n    // In case of an increase, the update formula used is the simplified version of the formula below:\\n    /*\\n            _normalizer * (BASE_27 + BASE_27 * amount / stablecoinsIssued) / BASE_27\\n        = _normalizer + (_normalizer * BASE_27 * amount * (BASE_27 / (_normalizedStables * normalizer))) / BASE_27\\n             = _normalizer + BASE_27 * amount / _normalizedStables\\n        */\\n    if (increase) {\\n      newNormalizerValue = _normalizer + (amount * BASE_27) / _normalizedStables;\\n    } else {\\n      newNormalizerValue = _normalizer - (amount * BASE_27) / _normalizedStables;\\n    }\\n    // If the `normalizer` gets too small or too big, it must be renormalized to later avoid the propagation of\\n    // rounding errors, as well as overflows. In this case, the function has to iterate through all the\\n    // supported collateral assets\\n    if (newNormalizerValue <= BASE_18 || newNormalizerValue >= BASE_36) {\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 collateralListLength = collateralListMem.length;\\n      // For each asset, we store the actual amount of stablecoins issued based on the `newNormalizerValue`\\n      // (and not a normalized value)\\n      // We ensure to preserve the invariant `sum(collateralNewNormalizedStables) = normalizedStables`\\n      uint128 newNormalizedStables;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        uint128 newCollateralNormalizedStable = ((uint256(ts.collaterals[collateralListMem[i]].normalizedStables)\\n              * newNormalizerValue) / BASE_27)\\n        .toUint128();\\n        newNormalizedStables += newCollateralNormalizedStable;\\n        ts.collaterals[collateralListMem[i]].normalizedStables = uint216(newCollateralNormalizedStable);\\n      }\\n      ts.normalizedStables = newNormalizedStables;\\n      newNormalizerValue = BASE_27;\\n    }\\n    ts.normalizer = newNormalizerValue.toUint128();\\n    if (!increase && ts.normalizedStables == 0) revert CannotBurnAllStableIssued();\\n    emit NormalizerUpdated(newNormalizerValue);\\n  }\\n}\\n\",\"keccak256\":\"0x52467df54a2a68910287c51c0ee42d304de44a7ccacd22fff8426911835356f3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibAuthorization.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\n/// @title LibAuthorization\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Derives the EIP-3009 nonce that binds the Parallelizer's `*WithAuthorization` entry\\n/// points to their full swap/redeem intent (output `to`, slippage, deadline, ...), closing the\\n/// front-running gap left by vanilla `receiveWithAuthorization` which only commits to the token\\n/// transfer itself.\\n/// @dev Off-chain, the authorizer signs a standard EIP-3009 `ReceiveWithAuthorization` with\\n/// `nonce = compute*Nonce(...)`. The facet recomputes the same value from the call arguments and\\n/// forwards it to the token; tampering with any bound field makes the signature invalid. Replay\\n/// protection is provided by the token's own `authorizationStates` mapping; retries use a fresh\\n/// `userSalt`.\\nlibrary LibAuthorization {\\n  // keccak256(\\\"SwapExactInputWithAuthorization(address from,address tokenIn,address tokenOut,uint256 amountIn,uint256\\n  // amountOutMin,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x9be969f74c66b263054aa69cfac8412777a0dc17ab007f81682c6b156ba06d79;\\n\\n  // keccak256(\\\"SwapExactOutputWithAuthorization(address from,address tokenIn,address tokenOut,uint256\\n  // amountOut,uint256 amountInMax,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;\\n\\n  // keccak256(\\\"RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32\\n  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 userSalt)\\\")\\n  bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =\\n    0xcff34e096e1842f6f6ae4c0d0c6eefd4855c8bdc5bc64155d7c14b2dbeee661a;\\n\\n  function computeSwapExactInputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountIn,\\n        amountOutMin,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeSwapExactOutputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountOut,\\n        amountInMax,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeRedeemNonce(\\n    address from,\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        REDEEM_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        amount,\\n        receiver,\\n        deadline,\\n        keccak256(abi.encodePacked(minAmountOuts)),\\n        keccak256(abi.encodePacked(forfeitTokens)),\\n        userSalt\\n      )\\n    );\\n  }\\n}\\n\",\"keccak256\":\"0xe41991a0a564f4f6443aeffd6f1519ae3decc8a9e1e625f51ddf2168453ea4f2\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"CannotBurnAllStableIssued\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotWhitelisted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnexpectedRedemptionTokens\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNormalizerValue\",\"type\":\"uint256\"}],\"name\":\"NormalizerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Redeemed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"quoteRedemptionCurve\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"}],\"name\":\"redeem\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"authData\",\"type\":\"bytes\"}],\"name\":\"redeemWithAuthorization\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"}],\"name\":\"redeemWithForfeit\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"updateNormalizer\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `Redeemer` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"returns\":{\"amounts\":\"Amount that would be obtained for each token in the `tokens` array\",\"tokens\":\"List of tokens that would be given\"}},\"redeem(uint256,address,uint256,uint256[],bytes32)\":{\"details\":\"The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function\",\"params\":{\"deadline\":\"Timestamp before which the redemption should have occured\",\"expectedTokensHash\":\"`keccak256(abi.encodePacked(tokens))` over the output list the caller was quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\",\"minAmountOuts\":\"Minimum amount of each token given back in the redemption to obtain\",\"receiver\":\"Address which should be receiving the output tokens\"},\"returns\":{\"amounts\":\"Amount given for each token in the `tokens` array\",\"tokens\":\"List of tokens returned\"}},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)\":{\"details\":\"The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.`expectedTokensHash` matters most here: a signature stays executable for its whole validity window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)\":{\"details\":\"Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount\"},\"updateNormalizer(uint256,bool)\":{\"details\":\"This function may be called by trusted addresses: these could be for instance savings contract minting stablecoins when they notice a profit\"}},\"title\":\"Redeemer\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"notice\":\"Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\"},\"redeem(uint256,address,uint256,uint256[],bytes32)\":{\"notice\":\"Redeems `amount` of stablecoins from the system\"},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)\":{\"notice\":\"Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)\":{\"notice\":\"Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`.\"},\"updateNormalizer(uint256,bool)\":{\"notice\":\"Updates the normalizer variable by `amount`\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Redeemer.sol\":\"Redeemer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was\\n  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since\\n  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`\\n  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity\\n  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x3362bd4532915b6e2b26b2fdc967a89ea66de5ea5f669d7a621ee69d75c02273\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IEIP3009.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IEIP3009\\n/// @notice Interface for EIP-3009: Transfer With Authorization\\ninterface IEIP3009 {\\n  /// @notice Execute a transfer with a signed authorization (EOA signature)\\n  /// @dev SECURITY: anyone may submit this call (no `msg.sender` restriction). Integrators that\\n  /// pair the transfer with downstream logic (e.g. swap, deposit, redeem) MUST use\\n  /// `receiveWithAuthorization` instead: a mempool watcher can otherwise frontrun the original\\n  /// transaction with a raw `transferWithAuthorization`, burning the nonce so the original\\n  /// reverts while the funds still move - causing the post-transfer logic to be skipped.\\n  /// Use this primitive only for direct payouts to a passive recipient (`msg.sender != to`).\\n  /// @param from The address of the sender\\n  /// @param to The address of the recipient\\n  /// @param value The amount of tokens to transfer\\n  /// @param validAfter The timestamp after which the authorization is valid\\n  /// @param validBefore The timestamp before which the authorization is valid\\n  /// @param nonce The nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Execute a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev SECURITY: see the EOA overload - this primitive is frontrun-prone and must not be used\\n  /// when the transfer is bound to follow-on logic. Use `receiveWithAuthorization` in that case.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EOA signature)\\n  /// @dev The caller must be the payee (`to` address). This has an additional check to ensure\\n  /// that the payee's address matches the caller of this function to prevent front-running attacks.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev The caller must be the payee (`to` address)\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Attempt to cancel an authorization\\n  /// @dev Works only if the authorization is not yet used.\\n  /// EOA wallet signatures should be packed in the order of r, s, v.\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external;\\n\\n  /// @notice Cancel an authorization (EIP-1271 compatible)\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external;\\n\\n  /// @notice Returns the state of an authorization\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @return true if the nonce is used\\n  function authorizationState(address authorizer, bytes32 nonce) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe34cfb584a925054c2e3569c4401c619cd2b928a7b9da04537e71a9089edf55a\",\"license\":\"MIT\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Redeemer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IRedeemer } from \\\"contracts/interfaces/IRedeemer.sol\\\";\\nimport { IEIP3009 } from \\\"contracts/interfaces/external/IEIP3009.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\nimport { LibAuthorization } from \\\"../libraries/LibAuthorization.sol\\\";\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Redeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `Redeemer` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\\ncontract Redeemer is IRedeemer, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  event Redeemed(\\n    uint256 amount,\\n    address[] tokens,\\n    uint256[] amounts,\\n    address[] forfeitTokens,\\n    address indexed from,\\n    address indexed to\\n  );\\n  event NormalizerUpdated(uint256 newNormalizerValue);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev The `minAmountOuts` list must reflect the amount of `tokens` returned\\n  /// @dev In normal conditions, the amount of tokens outputted by this function should be the amount\\n  /// of collateral assets supported by the system, following their order in the `collateralList`.\\n  /// @dev If one collateral has its liquidity managed through strategies, then it's possible that this asset\\n  /// has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption\\n  /// process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral\\n  /// assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering\\n  /// of the token list will be as follows:\\n  /// `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`\\n  /// @dev The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained\\n  /// by calling the `quoteRedemptionCurve` function\\n  /// @dev Tokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the\\n  /// whitelist, otherwise this function reverts\\n  /// @dev No approval is needed before calling this function\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), expectedTokensHash, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token\\n  /// even if it has enough immediately available to send the amount\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev This function may be called by trusted addresses: these could be for instance savings contract\\n  /// minting stablecoins when they notice a profit\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256) {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && s.transmuterStorage().isTrusted[msg.sender] == 0) {\\n      revert NotTrusted();\\n    }\\n    return _updateNormalizer(amount, increase);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    (tokens, amounts,) = _quoteRedemptionCurve(amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Working set passed by reference between `_redeem` and its loop helper, so the call\\n  /// site stays under the EVM stack-depth limit when compiling without via-IR.\\n  struct RedemptionExecution {\\n    uint256 amount;\\n    address from;\\n    address to;\\n    address[] tokens;\\n    uint256[] amounts;\\n    uint256[] subCollateralsTracker;\\n    uint256[] minAmountOuts;\\n    address[] forfeitTokens;\\n  }\\n\\n  /// @notice Internal function of the `redeem` function in the `Redeemer` contract\\n  function _redeem(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    nonReentrant\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    if (s.transmuterStorage().isRedemptionLive == 0) revert Paused();\\n    if (block.timestamp > deadline) revert TooLate();\\n\\n    RedemptionExecution memory redemption;\\n    redemption.amount = amount;\\n    redemption.to = to;\\n    redemption.minAmountOuts = minAmountOuts;\\n    redemption.forfeitTokens = forfeitTokens;\\n\\n    (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);\\n    if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();\\n    // `minAmountOuts` is positional, so it only protects quantities. Binding the output list itself is what\\n    // ties each minimum to the token it was quoted against, across a collateral rotation\\n    if (keccak256(abi.encodePacked(redemption.tokens)) != expectedTokensHash) revert UnexpectedRedemptionTokens();\\n    _updateNormalizer(amount, false);\\n\\n    redemption.from =\\n      _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n\\n    _distributeRedemption(redemption);\\n    emit Redeemed(\\n      redemption.amount,\\n      redemption.tokens,\\n      redemption.amounts,\\n      redemption.forfeitTokens,\\n      redemption.from,\\n      redemption.to\\n    );\\n    return (redemption.tokens, redemption.amounts);\\n  }\\n\\n  /// @notice Releases each non-forfeited collateral output to `redemption.to`. Extracted from `_redeem`\\n  /// so the parent function stays within the EVM stack-depth limit.\\n  function _distributeRedemption(RedemptionExecution memory redemption) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 indexCollateral;\\n    uint256 amountsLength = redemption.amounts.length;\\n    for (uint256 i; i < amountsLength; ++i) {\\n      if (redemption.amounts[i] < redemption.minAmountOuts[i]) revert TooSmallAmountOut();\\n      // If a token is in the `forfeitTokens` list, then it is not sent as part of the redemption process\\n      if (redemption.amounts[i] > 0 && LibHelpers.checkList(redemption.tokens[i], redemption.forfeitTokens) < 0) {\\n        Collateral storage collatInfo = ts.collaterals[collateralListMem[indexCollateral]];\\n        if (collatInfo.onlyWhitelisted > 0 && !LibWhitelist.checkWhitelist(collatInfo.whitelistData, redemption.to)) {\\n          revert NotWhitelisted();\\n        }\\n        if (collatInfo.isManaged > 0) {\\n          LibManager.release(redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config);\\n        } else {\\n          IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);\\n        }\\n      }\\n      if (redemption.subCollateralsTracker[indexCollateral] - 1 <= i) ++indexCollateral;\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer (auth flow) or burns directly from\\n  /// `msg.sender`, and returns the address to attribute the `Redeemed` event to.\\n  function _consumeAuthAndBurn(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    ITokenP tokenP = s.transmuterStorage().tokenP;\\n    if (authData.length > 0) {\\n      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n      tokenP.burnSelf(amount, address(this));\\n    } else {\\n      from = msg.sender;\\n      tokenP.burnSelf(amount, msg.sender);\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer via EIP-3009 `receiveWithAuthorization`,\\n  /// using a derived nonce that binds the full redemption intent.\\n  /// @return from The authorizer address (`params.from`), to attribute the redeem event to\\n  function _executeAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));\\n    if (params.value != amount) revert InvalidSwap();\\n    bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(\\n      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, params.nonce\\n    );\\n    IEIP3009(address(s.transmuterStorage().tokenP))\\n      .receiveWithAuthorization(\\n        params.from, address(this), params.value, params.validAfter, params.validBefore, derivedNonce, params.signature\\n      );\\n    return params.from;\\n  }\\n\\n  /// @dev This function reverts if `stablecoinsIssued==0`, which is expected behavior as there is nothing to redeem\\n  /// anyway in this case, or if the `amountBurnt` is greater than `stablecoinsIssued`\\n  /// @dev Invariant: `penaltyFactor` is evaluated once at the entry-time `collatRatio` and applied uniformly to the\\n  /// full `amountBurnt`. The curve is not path-integrated, so a single redemption that traverses into a lower-penalty\\n  /// segment still pays the entry-time rate on every unit burned. Splitting the same redemption into smaller calls\\n  /// can yield a strictly better blended rate when the path crosses an ascending segment of the curve. This is a\\n  /// deliberate design choice consistent with penalizing early redemptions during under-collateralization; the gap\\n  /// between single-call and path-integrated pricing scales with the ascending-segment slope and should be\\n  /// considered when calibrating `xRedemptionCurve`/`yRedemptionCurve`.\\n  function _quoteRedemptionCurve(uint256 amountBurnt)\\n    internal\\n    view\\n    returns (address[] memory tokens, uint256[] memory balances, uint256[] memory subCollateralsTracker)\\n  {\\n    uint64 collatRatio;\\n    uint256 stablecoinsIssued;\\n    (collatRatio, stablecoinsIssued, tokens, balances, subCollateralsTracker) = LibGetters.getCollateralRatio();\\n    if (amountBurnt >= stablecoinsIssued) revert CannotBurnAllStableIssued();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    int64[] memory yRedemptionCurveMem = ts.yRedemptionCurve;\\n    uint64 penaltyFactor;\\n    // If the protocol is under-collateralized, a penalty factor is applied to the returned amount of each asset\\n    if (collatRatio < BASE_9) {\\n      uint64[] memory xRedemptionCurveMem = ts.xRedemptionCurve;\\n      penaltyFactor = uint64(LibHelpers.piecewiseLinear(collatRatio, xRedemptionCurveMem, yRedemptionCurveMem));\\n    }\\n\\n    for (uint256 i; i < balances.length; ++i) {\\n      // The amount given for each token in reserves does not depend on the price of the tokens in reserve:\\n      // it is a proportion of the balance for each token computed as the ratio between the stablecoins\\n      // burnt relative to the amount of stablecoins issued.\\n      // If the protocol is over-collateralized, the amount of each token given is inversely proportional\\n      // to the collateral ratio.\\n      balances[i] = collatRatio >= BASE_9\\n        ? (amountBurnt * balances[i] * (uint64(yRedemptionCurveMem[yRedemptionCurveMem.length - 1])))\\n          / (stablecoinsIssued * collatRatio)\\n        : (amountBurnt * balances[i] * penaltyFactor) / (stablecoinsIssued * BASE_9);\\n    }\\n  }\\n\\n  /// @notice Updates the `normalizer` variable used to track stablecoins issued from each asset and globally\\n  function _updateNormalizer(uint256 amount, bool increase) internal returns (uint256 newNormalizerValue) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    uint256 _normalizedStables = ts.normalizedStables;\\n    // In case of an increase, the update formula used is the simplified version of the formula below:\\n    /*\\n            _normalizer * (BASE_27 + BASE_27 * amount / stablecoinsIssued) / BASE_27\\n        = _normalizer + (_normalizer * BASE_27 * amount * (BASE_27 / (_normalizedStables * normalizer))) / BASE_27\\n             = _normalizer + BASE_27 * amount / _normalizedStables\\n        */\\n    if (increase) {\\n      newNormalizerValue = _normalizer + (amount * BASE_27) / _normalizedStables;\\n    } else {\\n      newNormalizerValue = _normalizer - (amount * BASE_27) / _normalizedStables;\\n    }\\n    // If the `normalizer` gets too small or too big, it must be renormalized to later avoid the propagation of\\n    // rounding errors, as well as overflows. In this case, the function has to iterate through all the\\n    // supported collateral assets\\n    if (newNormalizerValue <= BASE_18 || newNormalizerValue >= BASE_36) {\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 collateralListLength = collateralListMem.length;\\n      // For each asset, we store the actual amount of stablecoins issued based on the `newNormalizerValue`\\n      // (and not a normalized value)\\n      // We ensure to preserve the invariant `sum(collateralNewNormalizedStables) = normalizedStables`\\n      uint128 newNormalizedStables;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        uint128 newCollateralNormalizedStable = ((uint256(ts.collaterals[collateralListMem[i]].normalizedStables)\\n              * newNormalizerValue) / BASE_27)\\n        .toUint128();\\n        newNormalizedStables += newCollateralNormalizedStable;\\n        ts.collaterals[collateralListMem[i]].normalizedStables = uint216(newCollateralNormalizedStable);\\n      }\\n      ts.normalizedStables = newNormalizedStables;\\n      newNormalizerValue = BASE_27;\\n    }\\n    ts.normalizer = newNormalizerValue.toUint128();\\n    if (!increase && ts.normalizedStables == 0) revert CannotBurnAllStableIssued();\\n    emit NormalizerUpdated(newNormalizerValue);\\n  }\\n}\\n\",\"keccak256\":\"0x1a67602de708b202cbfb4311b65c8e28294c043d059c53c66dcd9c7b1512d3c0\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibAuthorization.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\n/// @title LibAuthorization\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Derives the EIP-3009 nonce that binds the Parallelizer's `*WithAuthorization` entry\\n/// points to their full swap/redeem intent (output `to`, slippage, deadline, ...), closing the\\n/// front-running gap left by vanilla `receiveWithAuthorization` which only commits to the token\\n/// transfer itself.\\n/// @dev Off-chain, the authorizer signs a standard EIP-3009 `ReceiveWithAuthorization` with\\n/// `nonce = compute*Nonce(...)`. The facet recomputes the same value from the call arguments and\\n/// forwards it to the token; tampering with any bound field makes the signature invalid. Replay\\n/// protection is provided by the token's own `authorizationStates` mapping; retries use a fresh\\n/// `userSalt`.\\nlibrary LibAuthorization {\\n  // keccak256(\\\"SwapExactInputWithAuthorization(address from,address tokenIn,address tokenOut,uint256 amountIn,uint256\\n  // amountOutMin,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x9be969f74c66b263054aa69cfac8412777a0dc17ab007f81682c6b156ba06d79;\\n\\n  // keccak256(\\\"SwapExactOutputWithAuthorization(address from,address tokenIn,address tokenOut,uint256\\n  // amountOut,uint256 amountInMax,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;\\n\\n  // keccak256(\\\"RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32\\n  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 expectedTokensHash,bytes32 userSalt)\\\")\\n  bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =\\n    0xb6577f08e668b53303325a19233e8315142d69bedb6d7e1d8d0e9af2473486d4;\\n\\n  function computeSwapExactInputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountIn,\\n        amountOutMin,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeSwapExactOutputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountOut,\\n        amountInMax,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the redemption output list the\\n  /// authorizer was quoted, binding token identity and ordering rather than raw amounts alone\\n  function computeRedeemNonce(\\n    address from,\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        REDEEM_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        amount,\\n        receiver,\\n        deadline,\\n        keccak256(abi.encodePacked(minAmountOuts)),\\n        keccak256(abi.encodePacked(forfeitTokens)),\\n        expectedTokensHash,\\n        userSalt\\n      )\\n    );\\n  }\\n}\\n\",\"keccak256\":\"0x195b02224ec034756820857b7f88acc6ace194d00a68a9a6f0bcb8adf38963c8\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -407,13 +428,13 @@
       "quoteRedemptionCurve(uint256)": {
         "notice": "Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block"
       },
-      "redeem(uint256,address,uint256,uint256[])": {
+      "redeem(uint256,address,uint256,uint256[],bytes32)": {
         "notice": "Redeems `amount` of stablecoins from the system"
       },
-      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": {
+      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": {
         "notice": "Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer."
       },
-      "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": {
+      "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": {
         "notice": "Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`."
       },
       "updateNormalizer(uint256,bool)": {
@@ -424,13 +445,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0x83b1c8644d2339afe8dfcdb66e1dd1689b9660adcd907a823229ea5f5a99170d",
-    "nonce": "0xe7",
+    "hash": "0xe79e4995f6380da8fa4ca2583b08e0378b3aa96c40a401d8d6cf27f32fb5b4b1",
+    "nonce": "0x108",
     "origin": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02"
   },
   "receipt": {
-    "blockHash": "0x2a8ee493301fe4f5f6bfc523049e4d3f17f1f6f9eee5eb38a2a7571623666483",
-    "blockNumber": "0x186a79e",
-    "transactionIndex": "0x187"
+    "blockHash": "0x6e3456bc2a2d782c3250931803bebc784709f1a0ce564d2886d88fb75914a926",
+    "blockNumber": "0x18ef460",
+    "transactionIndex": "0x7c"
   }
 }
\ No newline at end of file
diff --git a/deployments/mainnet/RewardHandler.json b/deployments/mainnet/RewardHandler.json
index 5d8475d..cc408ba 100644
--- a/deployments/mainnet/RewardHandler.json
+++ b/deployments/mainnet/RewardHandler.json
@@ -1,5 +1,5 @@
 {
-  "address": "0xa5175c6000dfbc2cbf76b1fa65cd338ff237088b",
+  "address": "0x5ab916f3f3f834a5289d520077185ff8a9523eb9",
   "abi": [
     {
       "inputs": [],
@@ -18,12 +18,12 @@
     },
     {
       "inputs": [],
-      "name": "OdosSwapFailed",
+      "name": "ReentrantCall",
       "type": "error"
     },
     {
       "inputs": [],
-      "name": "ReentrantCall",
+      "name": "RewardSwapFailed",
       "type": "error"
     },
     {
@@ -42,6 +42,11 @@
       "name": "TooSmallAmountOut",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -88,8 +93,8 @@
   ],
   "contractName": "RewardHandler",
   "sourceName": "contracts/parallelizer/facets/RewardHandler.sol",
-  "bytecode": "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",
-  "deployedBytecode": "0x608060405234801561000f575f5ffd5b5060043610610029575f3560e01c806305b419341461002d575b5f5ffd5b61004061003b366004610cab565b610052565b60405190815260200160405180910390f35b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7580545f919060ff600160a81b90910416600119016100bd576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff60a81b191675020000000000000000000000000000000000000000001781557f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7561010c335f366107c5565b1580156101275750335f908152600782016020526040902054155b1561015e576040517fc22a648e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f816002018054806020026020016040519081016040528092919081815260200182805480156101b557602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610197575b505050505090505f815190505f8167ffffffffffffffff8111156101db576101db610c3f565b604051908082528060200260200182016040528015610204578160200160208202803683370190505b5090505f5b828110156102ba5783818151811061022357610223610d2f565b60209081029190910101516040516370a0823160e01b81523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa158015610271573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102959190610d43565b8282815181106102a7576102a7610d2f565b6020908102919091010152600101610209565b5083546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a0823190602401602060405180830381865afa158015610300573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103249190610d43565b90505f5f73cf5540fffcdc3d510b18bfca6d2b9987b07725596001600160a01b03168a6040516103549190610d5a565b5f604051808303815f865af19150503d805f811461038d576040519150601f19603f3d011682016040523d82523d5f602084013e610392565b606091505b5091509150816103a5576103a581610911565b86546040516370a0823160e01b815230600482015284916001600160a01b0316906370a0823190602401602060405180830381865afa1580156103ea573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061040e9190610d43565b1015610446576040517f672215de00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5f5f5b87811015610602575f89828151811061046557610465610d2f565b60209081029190910101516040516370a0823160e01b81523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa1580156104b3573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906104d79190610d43565b90508782815181106104eb576104eb610d2f565b602002602001015181101561051357604051631115766760e01b815260040160405180910390fd5b87828151811061052557610525610d2f565b60200260200101518111156105f9576001935089828151811061054a5761054a610d2f565b6020026020010151925087828151811061056657610566610d2f565b6020026020010151816105799190610d70565b9c508e8d10156105b5576040517fa1aabbe100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b826001600160a01b03167fbe1da12e92b73d3ecd35edcc32270e8ffaa4ee9fe30f671989b3d2e88a2c2ea28e6040516105f091815260200190565b60405180910390a25b5060010161044a565b508161062157604051631115766760e01b815260040160405180910390fd5b6001600160a01b0381165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a60205260409020805460ff16156107a25761070b6106fa82600701600101805461067990610d95565b80601f01602080910402602001604051908101604052809291908181526020018280546106a590610d95565b80156106f05780601f106106c7576101008083540402835291602001916106f0565b820191905f5260205f20905b8154815290600101906020018083116106d357829003601f168201915b5050505050610952565b6001600160a01b038416908e61099e565b6107a28c82600701600101805461072190610d95565b80601f016020809104026020016040519081016040528092919081815260200182805461074d90610d95565b80156107985780601f1061076f57610100808354040283529160200191610798565b820191905f5260205f20905b81548152906001019060200180831161077b57829003601f168201915b5050505050610a23565b5050885460ff60a81b1916600160a81b1790985550969998505050505050505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d545f906001600160a01b031681806108158388306108076004868b8d610dcd565b61081091610df4565b610abd565b91509150816109025763ffffffff8116156108f7577f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75805460ff60b01b19167601000000000000000000000000000000000000000000001781556040517f94c7d7ee0000000000000000000000000000000000000000000000000000000081526001600160a01b038516906394c7d7ee906108b8908b908b908b90600401610e5a565b5f604051808303815f87803b1580156108cf575f5ffd5b505af11580156108e1573d5f5f3e3d5ffd5b5050825460ff60b01b1916909255506109029050565b5f935050505061090a565b600193505050505b9392505050565b80511561092057805181602001fd5b6040517f45d4013e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5f5f61095e84610b95565b30945090925090505f82801561097657610976610e98565b03610997578080602001905181019061098f9190610ec3565b949350505050565b5050919050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052610a1e908490610bb6565b505050565b5f5f610a2e83610b95565b90925090505f828015610a4357610a43610e98565b03610ab75780806020019051810190610a5c9190610ec3565b6001600160a01b0316632afcf480856040518263ffffffff1660e01b8152600401610a8991815260200190565b5f604051808303815f87803b158015610aa0575f5ffd5b505af1158015610ab2573d5f5f3e3d5ffd5b505050505b50505050565b6040516001600160a01b038085166024830152831660448201527fffffffff00000000000000000000000000000000000000000000000000000000821660648201525f908190819060840160408051601f19818403018152918152602080830180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fb7009613000000000000000000000000000000000000000000000000000000001781525f808052918290528351939450919290918a5afa15610b8b575f516020805191945081901c150291505b5094509492505050565b5f606082806020019051810190610bac9190610ede565b9094909350915050565b5f5f60205f8451602086015f885af180610bd5576040513d5f823e3d81fd5b50505f513d91508115610bec578060011415610bf9565b6001600160a01b0384163b155b15610ab7576040517f5274afe70000000000000000000000000000000000000000000000000000000081526001600160a01b038516600482015260240160405180910390fd5b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f1916810167ffffffffffffffff81118282101715610c7c57610c7c610c3f565b604052919050565b5f67ffffffffffffffff821115610c9d57610c9d610c3f565b50601f01601f191660200190565b5f5f60408385031215610cbc575f5ffd5b82359150602083013567ffffffffffffffff811115610cd9575f5ffd5b8301601f81018513610ce9575f5ffd5b8035610cfc610cf782610c84565b610c53565b818152866020838501011115610d10575f5ffd5b816020840160208301375f602083830101528093505050509250929050565b634e487b7160e01b5f52603260045260245ffd5b5f60208284031215610d53575f5ffd5b5051919050565b5f82518060208501845e5f920191825250919050565b81810381811115610d8f57634e487b7160e01b5f52601160045260245ffd5b92915050565b600181811c90821680610da957607f821691505b602082108103610dc757634e487b7160e01b5f52602260045260245ffd5b50919050565b5f5f85851115610ddb575f5ffd5b83861115610de7575f5ffd5b5050820193919092039150565b80357fffffffff000000000000000000000000000000000000000000000000000000008116906004841015610e53577fffffffff00000000000000000000000000000000000000000000000000000000808560040360031b1b82161691505b5092915050565b6001600160a01b038416815260406020820152816040820152818360608301375f818301606090810191909152601f909201601f1916010192915050565b634e487b7160e01b5f52602160045260245ffd5b6001600160a01b0381168114610ec0575f5ffd5b50565b5f60208284031215610ed3575f5ffd5b815161090a81610eac565b5f5f60408385031215610eef575f5ffd5b825160018110610efd575f5ffd5b602084015190925067ffffffffffffffff811115610f19575f5ffd5b8301601f81018513610f29575f5ffd5b8051610f37610cf782610c84565b818152866020838501011115610f4b575f5ffd5b8160208401602083015e5f60208383010152809350505050925092905056fea264697066735822122061f2e881fc702fd22da9d01258cc5b103013facf6eb83ae8ddf66dab5c9a1c6d64736f6c634300081c0033",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -108,7 +113,7 @@
     "kind": "dev",
     "methods": {
       "sellRewards(uint256,bytes)": {
-        "details": "It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to Odos router for the token to be swapped"
+        "details": "It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to the configured `swapRouter` for the token to be swapped"
       }
     },
     "title": "RewardHandler",
@@ -117,9 +122,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "800000",
-        "executionCost": "829",
-        "totalCost": "800829"
+        "codeDepositCost": "810200",
+        "executionCost": "842",
+        "totalCost": "811042"
       },
       "external": {
         "sellRewards(uint256,bytes)": "infinite"
@@ -129,7 +134,7 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokens\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OdosSwapFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenObtained\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"balanceUpdate\",\"type\":\"uint256\"}],\"name\":\"RewardsSoldFor\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"sellRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `RewardHandler` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"details\":\"It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to Odos router for the token to be swapped\"}},\"title\":\"RewardHandler\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"notice\":\"IRewardHandler\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/RewardHandler.sol\":\"RewardHandler\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/RewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { IRewardHandler } from \\\"contracts/interfaces/IRewardHandler.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title RewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `RewardHandler` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\\ncontract RewardHandler is IRewardHandler, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n\\n  event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);\\n\\n  /// @notice IRewardHandler\\n  /// @dev It is impossible to sell a token that is a collateral through this function\\n  /// @dev Trusted sellers and governance only may call this function\\n  /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval\\n  /// transaction to Odos router for the token to be swapped\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    address[] memory list = ts.collateralList;\\n    uint256 listLength = list.length;\\n    uint256[] memory balances = new uint256[](listLength);\\n    // Getting the balances of all collateral assets of the protocol to see if those do not decrease during\\n    // the swap: this is the only way to check that collateral assets have not been sold\\n    // Not checking the `subCollaterals` here as swaps should try to increase the balance of one collateral\\n    for (uint256 i; i < listLength; ++i) {\\n      balances[i] = IERC20(list[i]).balanceOf(address(this));\\n    }\\n    uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));\\n    //solhint-disable-next-line\\n    (bool success, bytes memory result) = ODOS_ROUTER.call(payload);\\n    if (!success) _revertBytes(result);\\n    if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();\\n    bool hasIncreased;\\n    address collateral;\\n    for (uint256 i; i < listLength; ++i) {\\n      uint256 newBalance = IERC20(list[i]).balanceOf(address(this));\\n      if (newBalance < balances[i]) {\\n        revert InvalidSwap();\\n      } else if (newBalance > balances[i]) {\\n        hasIncreased = true;\\n        collateral = list[i];\\n        amountOut = newBalance - balances[i];\\n        if (amountOut < minAmountOut) revert TooSmallAmountOut();\\n        emit RewardsSoldFor(collateral, amountOut);\\n      }\\n    }\\n    if (!hasIncreased) revert InvalidSwap();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      IERC20(collateral).safeTransfer(LibManager.transferRecipient(collatInfo.managerData.config), amountOut);\\n      LibManager.invest(amountOut, collatInfo.managerData.config);\\n    }\\n  }\\n\\n  /// @notice Processes odos revert messages\\n  function _revertBytes(bytes memory errMsg) private pure {\\n    if (errMsg.length > 0) {\\n      //solhint-disable-next-line\\n      assembly (\\\"memory-safe\\\") {\\n        revert(add(32, errMsg), mload(errMsg))\\n      }\\n    }\\n    revert OdosSwapFailed();\\n  }\\n}\\n\",\"keccak256\":\"0xf01917011b3966f1783fa024ce6c56b5294ef0f65531bdc3f2e068649cd45038\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokens\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RewardSwapFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenObtained\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"balanceUpdate\",\"type\":\"uint256\"}],\"name\":\"RewardsSoldFor\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"sellRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `RewardHandler` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"details\":\"It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to the configured `swapRouter` for the token to be swapped\"}},\"title\":\"RewardHandler\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"notice\":\"IRewardHandler\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/RewardHandler.sol\":\"RewardHandler\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a call to the configured swap router\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to the swap router\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xb3604f35c5bb44791020588e00774299a6a4adae17d62d1e53cd8be86da6b709\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/RewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { IRewardHandler } from \\\"contracts/interfaces/IRewardHandler.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title RewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `RewardHandler` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\\ncontract RewardHandler is IRewardHandler, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n\\n  event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);\\n\\n  /// @notice IRewardHandler\\n  /// @dev It is impossible to sell a token that is a collateral through this function\\n  /// @dev Trusted sellers and governance only may call this function\\n  /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval\\n  /// transaction to the configured `swapRouter` for the token to be swapped\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    address[] memory list = ts.collateralList;\\n    uint256 listLength = list.length;\\n    uint256[] memory balances = new uint256[](listLength);\\n    // Getting the balances of all collateral assets of the protocol to see if those do not decrease during\\n    // the swap: this is the only way to check that collateral assets have not been sold\\n    // Not checking the `subCollaterals` here as swaps should try to increase the balance of one collateral\\n    for (uint256 i; i < listLength; ++i) {\\n      balances[i] = IERC20(list[i]).balanceOf(address(this));\\n    }\\n    uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));\\n    address swapRouter = ts.swapRouter;\\n    if (swapRouter == address(0)) revert ZeroAddress();\\n    //solhint-disable-next-line\\n    (bool success, bytes memory result) = swapRouter.call(payload);\\n    if (!success) _revertBytes(result);\\n    if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();\\n    bool hasIncreased;\\n    address collateral;\\n    for (uint256 i; i < listLength; ++i) {\\n      uint256 newBalance = IERC20(list[i]).balanceOf(address(this));\\n      if (newBalance < balances[i]) {\\n        revert InvalidSwap();\\n      } else if (newBalance > balances[i]) {\\n        hasIncreased = true;\\n        collateral = list[i];\\n        amountOut = newBalance - balances[i];\\n        if (amountOut < minAmountOut) revert TooSmallAmountOut();\\n        emit RewardsSoldFor(collateral, amountOut);\\n      }\\n    }\\n    if (!hasIncreased) revert InvalidSwap();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      IERC20(collateral).safeTransfer(LibManager.transferRecipient(collatInfo.managerData.config), amountOut);\\n      LibManager.invest(amountOut, collatInfo.managerData.config);\\n    }\\n  }\\n\\n  /// @notice Processes the router's revert messages\\n  function _revertBytes(bytes memory errMsg) private pure {\\n    if (errMsg.length > 0) {\\n      //solhint-disable-next-line\\n      assembly (\\\"memory-safe\\\") {\\n        revert(add(32, errMsg), mload(errMsg))\\n      }\\n    }\\n    revert RewardSwapFailed();\\n  }\\n}\\n\",\"keccak256\":\"0xa4e2fdeaaa43d78dfe1a81f458108856ebc92f27a7194e6293ac3c5084325beb\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -145,13 +150,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0x14fd05af892e2125aa2cb42b5f99c9434926e22c73ffe01a83ee59179b3bde6b",
-    "nonce": "0xe8",
+    "hash": "0x2984681559a1b2dce01b37e64310aab42ef44d080215a1497c92417c9ffc2e33",
+    "nonce": "0x109",
     "origin": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02"
   },
   "receipt": {
-    "blockHash": "0x505f7b259167bb0c5268bd4d757e3a99928e92c2755a97cc4ab880ed960eef3c",
-    "blockNumber": "0x186a79f",
-    "transactionIndex": "0x1ea"
+    "blockHash": "0xde197ad504a057577c813625b839897d9f08d0e4653d85d3a507d0d54020b06e",
+    "blockNumber": "0x18ef461",
+    "transactionIndex": "0xc"
   }
 }
\ No newline at end of file
diff --git a/deployments/mainnet/SettersGovernor.json b/deployments/mainnet/SettersGovernor.json
index 59c272c..66f049e 100644
--- a/deployments/mainnet/SettersGovernor.json
+++ b/deployments/mainnet/SettersGovernor.json
@@ -1,5 +1,5 @@
 {
-  "address": "0xb5a980349434a46687f425075f5558cd185ab9fa",
+  "address": "0x81a85266ca7dfcfe48a58349e15b258a91d68945",
   "abi": [
     {
       "inputs": [],
@@ -57,6 +57,11 @@
       "name": "InvalidParams",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "InvalidPayee",
+      "type": "error"
+    },
     {
       "inputs": [],
       "name": "InvalidRate",
@@ -135,6 +140,11 @@
       "name": "SafeERC20FailedOperation",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
     {
       "inputs": [],
       "name": "ZeroAmount",
@@ -285,6 +295,31 @@
       "name": "OracleSet",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "collateral",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "previousTarget",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "newTarget",
+          "type": "uint256"
+        }
+      ],
+      "name": "OracleTargetUpdated",
+      "type": "event"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -405,6 +440,19 @@
       "name": "SurplusBufferRatioUpdated",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "swapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "SwapRouterUpdated",
+      "type": "event"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -601,6 +649,19 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "swapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "setSwapRouter",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -712,8 +773,8 @@
   ],
   "contractName": "SettersGovernor",
   "sourceName": "contracts/parallelizer/facets/SettersGovernor.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -759,6 +820,9 @@
       "setCollateralManager(address,bool,(address[],bytes))": {
         "details": "Funds need to have been withdrawn from the eventual previous manager prior to this call"
       },
+      "setSwapRouter(address)": {
+        "details": "The payload is executed with a raw call, so any router can be configured. It is chain specific and must be set on every deployment before rewards can be sold"
+      },
       "updatePayees(address[],uint256[],bool)": {
         "params": {
           "_payees": "The new payee addresses",
@@ -782,9 +846,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "3353000",
-        "executionCost": "3729",
-        "totalCost": "3356729"
+        "codeDepositCost": "3440800",
+        "executionCost": "3842",
+        "totalCost": "3444642"
       },
       "external": {
         "addCollateral(address)": "infinite",
@@ -795,6 +859,7 @@
         "setAccessManager(address)": "infinite",
         "setCollateralManager(address,bool,(address[],bytes))": "infinite",
         "setOracle(address,bytes)": "infinite",
+        "setSwapRouter(address)": "infinite",
         "setWhitelistStatus(address,uint8,bytes)": "infinite",
         "toggleTrusted(address,uint8)": "infinite",
         "updateOracle(address)": "infinite",
@@ -804,12 +869,17 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AboveCap\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyAdded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CollateralBacked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccessManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParams\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidWhitelistStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ManagerHasAssets\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OracleUpdateFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentAllowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requestedDecrease\",\"type\":\"uint256\"}],\"name\":\"SafeERC20FailedDecreaseAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"indexed\":false,\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"CollateralManagerSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"}],\"name\":\"CollateralWhitelistStatusUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleasedToPayee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"OracleSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"PayeeAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"ReservesAdjusted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"SlippageToleranceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"SurplusBufferRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isTrusted\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"enum TrustedType\",\"name\":\"trustedType\",\"type\":\"uint8\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"addCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"adjustStablecoins\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"changeAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"}],\"name\":\"revokeCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAccessManager\",\"type\":\"address\"}],\"name\":\"setAccessManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"setCollateralManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"setOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"}],\"name\":\"setWhitelistStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"enum TrustedType\",\"name\":\"t\",\"type\":\"uint8\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"updateOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_payees\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_shares\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"_skipRelease\",\"type\":\"bool\"}],\"name\":\"updatePayees\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"updateSlippageTolerance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"updateSurplusBufferRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `SettersGovernor` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedDecreaseAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failed `decreaseAllowance` request.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"addCollateral(address)\":{\"details\":\"Collateral assets with a fee on transfer are not supported by the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"details\":\"The amount passed here must be an absolute amount\"},\"changeAllowance(address,address,uint256)\":{\"details\":\"This function can typically be used to grant allowance to a newly added manager for it to pull the funds associated to the collateral it corresponds to\"},\"recoverERC20(address,address,address,uint256)\":{\"details\":\"No check is made on the collateral that is redeemed: this function could typically be used by a governance during a manual rebalance of the reserves of the system`collateral` is different from `token` only in the case of a managed collateral\"},\"revokeCollateral(address,bool)\":{\"details\":\"Require `collatInfo.normalizedStables == 0`, that is to say that the collateral is not used to back stablesThe system may still have a non null balance of the collateral that is revoked: this should later be handled through a recoverERC20 callFunds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is true\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"details\":\"Funds need to have been withdrawn from the eventual previous manager prior to this call\"},\"updatePayees(address[],uint256[],bool)\":{\"params\":{\"_payees\":\"The new payee addresses\",\"_shares\":\"The new shares for each payee\",\"_skipRelease\":\"If true, skips the automatic income release before updating\"}},\"updateSlippageTolerance(address,uint256)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when calling the `processSurplus` function\"},\"updateSurplusBufferRatio(uint64)\":{\"details\":\"The surplus buffer ratio is the minimum collateral ratio required after surplus processing\",\"params\":{\"_surplusBufferRatio\":\"The new surplus buffer ratio in BASE_9\"}}},\"title\":\"SettersGovernor\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addCollateral(address)\":{\"notice\":\"Add `collateral` as a supported collateral in the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"notice\":\"Adjusts the amount of stablecoins issued from `collateral` by `amount`\"},\"changeAllowance(address,address,uint256)\":{\"notice\":\"Sets the allowance of the contract on `token` for `spender` to `amount`\"},\"recoverERC20(address,address,address,uint256)\":{\"notice\":\"Recovers `amount` of `token` from the Parallelizer contract\"},\"revokeCollateral(address,bool)\":{\"notice\":\"Revokes `collateral` from the system\"},\"setAccessManager(address)\":{\"notice\":\"Sets a new access manager address\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"notice\":\"Sets (or unsets) a collateral manager  `collateral`\"},\"setOracle(address,bytes)\":{\"notice\":\"Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations\"},\"setWhitelistStatus(address,uint8,bytes)\":{\"notice\":\"Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist\"},\"toggleTrusted(address,uint8)\":{\"notice\":\"Changes the trusted status for `sender` when for selling rewards or updating the normalizer\"},\"updateOracle(address)\":{\"notice\":\"Update oracle data for a given `collateral`\"},\"updatePayees(address[],uint256[],bool)\":{\"notice\":\"Updates the payees and their shares\"},\"updateSlippageTolerance(address,uint256)\":{\"notice\":\"Updates the slippage tolerance for a `collateral`\"},\"updateSurplusBufferRatio(uint64)\":{\"notice\":\"Updates the surplus buffer ratio\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/SettersGovernor.sol\":\"SettersGovernor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xd4d195b62841c28dd5f248d09e682c3c81bda24b471cd8a5d8efe498519ea50d\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/SettersGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { ISettersGovernor } from \\\"contracts/interfaces/ISetters.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibSetters } from \\\"../libraries/LibSetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title SettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\\ncontract SettersGovernor is AccessManagedModifiers, ISettersGovernor {\\n  using SafeERC20 for IERC20;\\n\\n  event Recovered(address indexed token, address indexed to, uint256 amount);\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev No check is made on the collateral that is redeemed: this function could typically be used by a\\n  /// governance during a manual rebalance of the reserves of the system\\n  /// @dev `collateral` is different from `token` only in the case of a managed collateral\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);\\n    else token.safeTransfer(to, amount);\\n    emit Recovered(address(token), to, amount);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setAccessManager(address _newAccessManager) external restricted {\\n    LibSetters.setAccessManager(IAccessManager(_newAccessManager));\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the\\n  /// funds associated to the collateral it corresponds to\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {\\n    uint256 currentAllowance = token.allowance(address(this), spender);\\n    if (currentAllowance < amount) {\\n      token.safeIncreaseAllowance(spender, amount - currentAllowance);\\n    } else if (currentAllowance > amount) {\\n      token.safeDecreaseAllowance(spender, currentAllowance - amount);\\n    }\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function toggleTrusted(address sender, TrustedType t) external restricted {\\n    LibSetters.toggleTrusted(sender, t);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Collateral assets with a fee on transfer are not supported by the system\\n  function addCollateral(address collateral) external restricted {\\n    LibSetters.addCollateral(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev The amount passed here must be an absolute amount\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {\\n    LibSetters.adjustStablecoins(collateral, amount, increase);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral\\n  /// is not used to back stables\\n  /// @dev The system may still have a non null balance of the collateral that is revoked: this should later\\n  /// be handled through a recoverERC20 call\\n  /// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is\\n  /// true\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {\\n    LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setOracle(address collateral, bytes memory oracleConfig) external restricted {\\n    LibSetters.setOracle(collateral, oracleConfig);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateOracle(address collateral) external {\\n    if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    LibOracle.updateOracle(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setWhitelistStatus(\\n    address collateral,\\n    uint8 whitelistStatus,\\n    bytes memory whitelistData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external restricted {\\n    LibSetters.updatePayees(_payees, _shares, _skipRelease);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external restricted {\\n    LibSetters.updateSlippageTolerance(collateral, slippageTolerance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {\\n    LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);\\n  }\\n}\\n\",\"keccak256\":\"0x3d0d0351ef8f06a401c421d2f76b4227e4819935583ad29f44fc6dc59f5ea021\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport { LibSurplus } from \\\"./LibSurplus.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { LibDiamond } from \\\"./LibDiamond.sol\\\";\\nimport { LibWhitelist } from \\\"./LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibSetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibSetters.sol\\nlibrary LibSetters {\\n  using SafeCast for uint256;\\n\\n  event CollateralAdded(address indexed collateral);\\n  event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);\\n  event CollateralRevoked(address indexed collateral);\\n  event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);\\n  event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);\\n  event OracleSet(address indexed collateral, bytes oracleConfig);\\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n  event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);\\n  event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);\\n  event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);\\n  event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);\\n  event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);\\n  event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);\\n  event PayeeAdded(address indexed payee, uint256 shares);\\n  event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);\\n  event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GOVERNOR ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `setAccessManager`\\n  function setAccessManager(IAccessManager _newAccessManager) internal {\\n    if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();\\n    DiamondStorage storage ds = s.diamondStorage();\\n    address previousAccessManager = address(ds.accessManager);\\n    ds.accessManager = _newAccessManager;\\n    emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));\\n  }\\n\\n  /// @notice Internal version of `setCollateralManager`\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    internal\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    if (managerData.config.length != 0) {\\n      // The first subCollateral given should be the actual collateral asset\\n      if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();\\n      // Sanity check on the manager data that is passed\\n      LibManager.parseManagerConfig(managerData.config);\\n      collatInfo.isManaged = 1;\\n    } else {\\n      collatInfo.isManaged = 0;\\n    }\\n    collatInfo.managerData = managerData;\\n    emit CollateralManagerSet(collateral, managerData);\\n  }\\n\\n  /// @notice Internal version of `toggleTrusted`\\n  function toggleTrusted(address sender, TrustedType t) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 trustedStatus;\\n    if (t == TrustedType.Updater) {\\n      trustedStatus = 1 - ts.isTrusted[sender];\\n      ts.isTrusted[sender] = trustedStatus;\\n    } else {\\n      trustedStatus = 1 - ts.isSellerTrusted[sender];\\n      ts.isSellerTrusted[sender] = trustedStatus;\\n    }\\n    emit TrustedToggled(sender, trustedStatus == 1, t);\\n  }\\n\\n  /// @notice Internal version of `addCollateral`\\n  function addCollateral(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals != 0) revert AlreadyAdded();\\n    collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());\\n    ts.collateralList.push(collateral);\\n    emit CollateralAdded(collateral);\\n  }\\n\\n  /// @notice Internal version of `adjustStablecoins`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();\\n    if (increase) {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables + normalizedAmount;\\n      if (uint256(collatInfo.normalizedStables) * uint256(ts.normalizer) / BASE_27 > collatInfo.stablecoinCap) {\\n        revert AboveCap();\\n      }\\n    } else {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables - normalizedAmount;\\n    }\\n    emit ReservesAdjusted(collateral, amount, increase);\\n  }\\n\\n  /// @notice Internal version of `revokeCollateral`\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (collatInfo.normalizedStables > 0) revert CollateralBacked();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    delete ts.collaterals[collateral];\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 length = collateralListMem.length;\\n    for (uint256 i; i < length - 1; ++i) {\\n      if (collateralListMem[i] == collateral) {\\n        ts.collateralList[i] = collateralListMem[length - 1];\\n        break;\\n      }\\n    }\\n    ts.collateralList.pop();\\n    emit CollateralRevoked(collateral);\\n  }\\n\\n  /// @notice Internal version of `setOracle`\\n  function setOracle(address collateral, bytes memory oracleConfig) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    (,,,, bytes memory hyperparameters) =\\n      abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    if (userDeviation > burnRatioDeviation) revert InvalidParams();\\n    // Checks oracle validity\\n    LibOracle.readMint(oracleConfig);\\n    collatInfo.oracleConfig = oracleConfig;\\n    emit OracleSet(collateral, oracleConfig);\\n  }\\n\\n  /// @notice Internal version of `setWhitelistStatus`\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {\\n    if (whitelistStatus > 1) revert InvalidWhitelistStatus();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (whitelistStatus == 1) {\\n      // Sanity check\\n      LibWhitelist.checkWhitelist(whitelistData, address(this));\\n      collatInfo.whitelistData = whitelistData;\\n    } else {\\n      // If whitelist is revoked, clear the whitelist data\\n      collatInfo.whitelistData = \\\"\\\";\\n    }\\n    collatInfo.onlyWhitelisted = whitelistStatus;\\n    emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GUARDIAN ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `pause` \\u2014 sets the action's live flag to `0`\\n  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance\\n  /// call cannot pass silently\\n  function pause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 0);\\n  }\\n\\n  /// @notice Internal version of `unpause` \\u2014 sets the action's live flag to `1`\\n  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance\\n  /// call cannot pass silently\\n  function unpause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 1);\\n  }\\n\\n  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`\\n  /// to unpause. Reverts on no-op transitions.\\n  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;\\n      if (currentIsLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      if (action == ActionType.Mint) {\\n        collatInfo.isMintLive = targetIsLive;\\n      } else {\\n        collatInfo.isBurnLive = targetIsLive;\\n      }\\n    } else {\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      if (ts.isRedemptionLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      ts.isRedemptionLive = targetIsLive;\\n    }\\n    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);\\n  }\\n\\n  /// @notice Internal version of `setFees`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);\\n    if (mint) {\\n      collatInfo.xFeeMint = xFee;\\n      collatInfo.yFeeMint = yFee;\\n    } else {\\n      collatInfo.xFeeBurn = xFee;\\n      collatInfo.yFeeBurn = yFee;\\n    }\\n    emit FeesSet(collateral, xFee, yFee, mint);\\n  }\\n\\n  /// @notice Internal version of `setRedemptionCurveParams`\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    LibSetters.checkFees(xFee, yFee, ActionType.Redeem);\\n    ts.xRedemptionCurve = xFee;\\n    ts.yRedemptionCurve = yFee;\\n    emit RedemptionCurveParamsSet(xFee, yFee);\\n  }\\n\\n  /// @notice Internal version of `toggleWhitelist`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];\\n    ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;\\n    emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);\\n  }\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a collateral\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    collatInfo.stablecoinCap = stablecoinCap;\\n    emit StablecoinCapSet(collateral, stablecoinCap);\\n  }\\n\\n  /// @notice Internal version of `updatePayees`\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) internal {\\n    if (_payees.length == 0 || _payees.length > MAX_PAYEES) revert InvalidLengths();\\n    if (_payees.length != _shares.length) revert ArrayLengthMismatch();\\n    /// @dev Distribute the fees before updating the fee receivers.\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!_skipRelease) {\\n      uint256 income = ts.tokenP.balanceOf(address(this));\\n      if (income > 0 && ts.payees.length > 0) {\\n        LibSurplus.release(income, ts.payees);\\n      }\\n    }\\n\\n    // Zero out stale shares for old payees\\n    uint256 i = 0;\\n    for (; i < ts.payees.length; ++i) {\\n      ts.shares[ts.payees[i]] = 0;\\n    }\\n    delete ts.payees;\\n    uint256 _totalShares = 0;\\n    i = 0;\\n    for (; i < _payees.length; ++i) {\\n      for (uint256 j = 0; j < i; ++j) {\\n        if (_payees[j] == _payees[i]) revert AlreadyAdded();\\n      }\\n      _totalShares += _addPayee(_payees[i], _shares[i]);\\n    }\\n    ts.totalShares = _totalShares;\\n  }\\n\\n  /// @notice Internal version of `updateSlippageTolerance`\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) internal {\\n    if (slippageTolerance > BASE_9) revert InvalidRate();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.slippageTolerance[collateral] = slippageTolerance;\\n    emit SlippageToleranceUpdated(collateral, slippageTolerance);\\n  }\\n\\n  /// @notice Internal version of `updateSurplusBufferRatio`\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {\\n    if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.surplusBufferRatio = _surplusBufferRatio;\\n    emit SurplusBufferRatioUpdated(_surplusBufferRatio);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions\\n  function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {\\n    uint256 n = xFee.length;\\n    if (n != yFee.length || n == 0) revert InvalidParams();\\n    if (\\n      // Mint inflexion points should be in [0,BASE_9[\\n      // We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9\\n      // Hence we consider BASE_12 as the max value (100% fees) for yFeeMint\\n      // Burn inflexion points should be in [0,BASE_9] but fees should be constant in\\n      // the first segment [BASE_9, x_{n-1}[\\n      // Redemption inflexion points should be in [0,BASE_9]\\n      (action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))\\n        || (action == ActionType.Burn\\n          && (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1]))))\\n        || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))\\n    ) {\\n      revert InvalidParams();\\n    }\\n\\n    for (uint256 i; i < n - 1; ++i) {\\n      if (\\n        // xFee strictly increasing and yFee increasing for mints\\n        // xFee strictly decreasing and yFee increasing for burns\\n        // xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions\\n        (action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))\\n      ) revert InvalidParams();\\n    }\\n\\n    // If a mint or burn fee is negative, we need to check that accounts atomically minting\\n    // (from any collateral) and then burning cannot get more than their initial value\\n    if (yFee[0] < 0) {\\n      if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 length = collateralListMem.length;\\n      if (action == ActionType.Mint) {\\n        // This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;\\n          if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n      if (action == ActionType.Burn) {\\n        // This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;\\n          if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n    }\\n  }\\n\\n  /// @notice Add a new fee receiver.\\n  /// @param _payee The address of the fee receiver.\\n  /// @param _shares The number of shares assigned to the fee receiver.\\n  function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {\\n    if (_shares == 0) revert ZeroAmount();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n\\n    ts.payees.push(_payee);\\n    ts.shares[_payee] = _shares;\\n    emit PayeeAdded(_payee, _shares);\\n    return _shares;\\n  }\\n}\\n\",\"keccak256\":\"0x9e41915e7fb03ef3b054f7ce0b7ab297e3b8f5c05ab1e7ebe072e22f11b22362\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AboveCap\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyAdded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CollateralBacked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccessManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParams\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidPayee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidWhitelistStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ManagerHasAssets\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OracleUpdateFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentAllowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requestedDecrease\",\"type\":\"uint256\"}],\"name\":\"SafeERC20FailedDecreaseAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"indexed\":false,\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"CollateralManagerSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"}],\"name\":\"CollateralWhitelistStatusUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleasedToPayee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"OracleSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"previousTarget\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newTarget\",\"type\":\"uint256\"}],\"name\":\"OracleTargetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"PayeeAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"ReservesAdjusted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"SlippageToleranceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"SurplusBufferRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"swapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isTrusted\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"enum TrustedType\",\"name\":\"trustedType\",\"type\":\"uint8\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"addCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"adjustStablecoins\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"changeAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"}],\"name\":\"revokeCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAccessManager\",\"type\":\"address\"}],\"name\":\"setAccessManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"setCollateralManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"setOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"swapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"}],\"name\":\"setWhitelistStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"enum TrustedType\",\"name\":\"t\",\"type\":\"uint8\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"updateOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_payees\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_shares\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"_skipRelease\",\"type\":\"bool\"}],\"name\":\"updatePayees\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"updateSlippageTolerance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"updateSurplusBufferRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `SettersGovernor` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedDecreaseAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failed `decreaseAllowance` request.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"addCollateral(address)\":{\"details\":\"Collateral assets with a fee on transfer are not supported by the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"details\":\"The amount passed here must be an absolute amount\"},\"changeAllowance(address,address,uint256)\":{\"details\":\"This function can typically be used to grant allowance to a newly added manager for it to pull the funds associated to the collateral it corresponds to\"},\"recoverERC20(address,address,address,uint256)\":{\"details\":\"No check is made on the collateral that is redeemed: this function could typically be used by a governance during a manual rebalance of the reserves of the system`collateral` is different from `token` only in the case of a managed collateral\"},\"revokeCollateral(address,bool)\":{\"details\":\"Require `collatInfo.normalizedStables == 0`, that is to say that the collateral is not used to back stablesThe system may still have a non null balance of the collateral that is revoked: this should later be handled through a recoverERC20 callFunds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is true\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"details\":\"Funds need to have been withdrawn from the eventual previous manager prior to this call\"},\"setSwapRouter(address)\":{\"details\":\"The payload is executed with a raw call, so any router can be configured. It is chain specific and must be set on every deployment before rewards can be sold\"},\"updatePayees(address[],uint256[],bool)\":{\"params\":{\"_payees\":\"The new payee addresses\",\"_shares\":\"The new shares for each payee\",\"_skipRelease\":\"If true, skips the automatic income release before updating\"}},\"updateSlippageTolerance(address,uint256)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when calling the `processSurplus` function\"},\"updateSurplusBufferRatio(uint64)\":{\"details\":\"The surplus buffer ratio is the minimum collateral ratio required after surplus processing\",\"params\":{\"_surplusBufferRatio\":\"The new surplus buffer ratio in BASE_9\"}}},\"title\":\"SettersGovernor\",\"version\":1},\"userdoc\":{\"events\":{\"OracleTargetUpdated(address,uint256,uint256)\":{\"notice\":\"Emitted when a MAX target price is ratcheted up by `updateOracle`\"}},\"kind\":\"user\",\"methods\":{\"addCollateral(address)\":{\"notice\":\"Add `collateral` as a supported collateral in the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"notice\":\"Adjusts the amount of stablecoins issued from `collateral` by `amount`\"},\"changeAllowance(address,address,uint256)\":{\"notice\":\"Sets the allowance of the contract on `token` for `spender` to `amount`\"},\"recoverERC20(address,address,address,uint256)\":{\"notice\":\"Recovers `amount` of `token` from the Parallelizer contract\"},\"revokeCollateral(address,bool)\":{\"notice\":\"Revokes `collateral` from the system\"},\"setAccessManager(address)\":{\"notice\":\"Sets a new access manager address\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"notice\":\"Sets (or unsets) a collateral manager  `collateral`\"},\"setOracle(address,bytes)\":{\"notice\":\"Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations\"},\"setSwapRouter(address)\":{\"notice\":\"Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\"},\"setWhitelistStatus(address,uint8,bytes)\":{\"notice\":\"Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist\"},\"toggleTrusted(address,uint8)\":{\"notice\":\"Changes the trusted status for `sender` when for selling rewards or updating the normalizer\"},\"updateOracle(address)\":{\"notice\":\"Update oracle data for a given `collateral`\"},\"updatePayees(address[],uint256[],bool)\":{\"notice\":\"Updates the payees and their shares\"},\"updateSlippageTolerance(address,uint256)\":{\"notice\":\"Updates the slippage tolerance for a `collateral`\"},\"updateSurplusBufferRatio(uint64)\":{\"notice\":\"Updates the surplus buffer ratio\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/SettersGovernor.sol\":\"SettersGovernor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n\\n  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain\\n  /// specific and must be set on every deployment before rewards can be sold\\n  function setSwapRouter(address swapRouter) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xe62d2880420afb053498b01f1def17d4c8e2c6c9b48cc5a71d013150a5ca8db4\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/SettersGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { ISettersGovernor } from \\\"contracts/interfaces/ISetters.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibSetters } from \\\"../libraries/LibSetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title SettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\\ncontract SettersGovernor is AccessManagedModifiers, ISettersGovernor {\\n  using SafeERC20 for IERC20;\\n\\n  event Recovered(address indexed token, address indexed to, uint256 amount);\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev No check is made on the collateral that is redeemed: this function could typically be used by a\\n  /// governance during a manual rebalance of the reserves of the system\\n  /// @dev `collateral` is different from `token` only in the case of a managed collateral\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);\\n    else token.safeTransfer(to, amount);\\n    emit Recovered(address(token), to, amount);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setAccessManager(address _newAccessManager) external restricted {\\n    LibSetters.setAccessManager(IAccessManager(_newAccessManager));\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the\\n  /// funds associated to the collateral it corresponds to\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {\\n    uint256 currentAllowance = token.allowance(address(this), spender);\\n    if (currentAllowance < amount) {\\n      token.safeIncreaseAllowance(spender, amount - currentAllowance);\\n    } else if (currentAllowance > amount) {\\n      token.safeDecreaseAllowance(spender, currentAllowance - amount);\\n    }\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function toggleTrusted(address sender, TrustedType t) external restricted {\\n    LibSetters.toggleTrusted(sender, t);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Collateral assets with a fee on transfer are not supported by the system\\n  function addCollateral(address collateral) external restricted {\\n    LibSetters.addCollateral(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev The amount passed here must be an absolute amount\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {\\n    LibSetters.adjustStablecoins(collateral, amount, increase);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral\\n  /// is not used to back stables\\n  /// @dev The system may still have a non null balance of the collateral that is revoked: this should later\\n  /// be handled through a recoverERC20 call\\n  /// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is\\n  /// true\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {\\n    LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setOracle(address collateral, bytes memory oracleConfig) external restricted {\\n    LibSetters.setOracle(collateral, oracleConfig);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateOracle(address collateral) external {\\n    if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    LibOracle.updateOracle(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setWhitelistStatus(\\n    address collateral,\\n    uint8 whitelistStatus,\\n    bytes memory whitelistData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external restricted {\\n    LibSetters.updatePayees(_payees, _shares, _skipRelease);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external restricted {\\n    LibSetters.updateSlippageTolerance(collateral, slippageTolerance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {\\n    LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setSwapRouter(address swapRouter) external restricted {\\n    LibSetters.setSwapRouter(swapRouter);\\n  }\\n}\\n\",\"keccak256\":\"0x7c64a27bfb326989b6fdc21b3982ef5ce95aa2a576a4edc6d8334a8820f3b8fb\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport { LibSurplus } from \\\"./LibSurplus.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { LibDiamond } from \\\"./LibDiamond.sol\\\";\\nimport { LibWhitelist } from \\\"./LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibSetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibSetters.sol\\nlibrary LibSetters {\\n  using SafeCast for uint256;\\n\\n  event CollateralAdded(address indexed collateral);\\n  event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);\\n  event CollateralRevoked(address indexed collateral);\\n  event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);\\n  event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);\\n  event OracleSet(address indexed collateral, bytes oracleConfig);\\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n  event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);\\n  event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);\\n  event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);\\n  event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);\\n  event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);\\n  event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);\\n  event PayeeAdded(address indexed payee, uint256 shares);\\n  event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);\\n  event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);\\n  event SwapRouterUpdated(address indexed swapRouter);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GOVERNOR ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `setAccessManager`\\n  function setAccessManager(IAccessManager _newAccessManager) internal {\\n    if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();\\n    DiamondStorage storage ds = s.diamondStorage();\\n    address previousAccessManager = address(ds.accessManager);\\n    ds.accessManager = _newAccessManager;\\n    emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));\\n  }\\n\\n  /// @notice Internal version of `setCollateralManager`\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    internal\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    if (managerData.config.length != 0) {\\n      // The first subCollateral given should be the actual collateral asset\\n      if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();\\n      // Sanity check on the manager data that is passed\\n      LibManager.parseManagerConfig(managerData.config);\\n      collatInfo.isManaged = 1;\\n    } else {\\n      collatInfo.isManaged = 0;\\n    }\\n    collatInfo.managerData = managerData;\\n    emit CollateralManagerSet(collateral, managerData);\\n  }\\n\\n  /// @notice Internal version of `toggleTrusted`\\n  function toggleTrusted(address sender, TrustedType t) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 trustedStatus;\\n    if (t == TrustedType.Updater) {\\n      trustedStatus = 1 - ts.isTrusted[sender];\\n      ts.isTrusted[sender] = trustedStatus;\\n    } else {\\n      trustedStatus = 1 - ts.isSellerTrusted[sender];\\n      ts.isSellerTrusted[sender] = trustedStatus;\\n    }\\n    emit TrustedToggled(sender, trustedStatus == 1, t);\\n  }\\n\\n  /// @notice Internal version of `addCollateral`\\n  function addCollateral(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals != 0) revert AlreadyAdded();\\n    collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());\\n    ts.collateralList.push(collateral);\\n    emit CollateralAdded(collateral);\\n  }\\n\\n  /// @notice Internal version of `adjustStablecoins`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();\\n    if (increase) {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables + normalizedAmount;\\n      if (uint256(collatInfo.normalizedStables) * uint256(ts.normalizer) / BASE_27 > collatInfo.stablecoinCap) {\\n        revert AboveCap();\\n      }\\n    } else {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables - normalizedAmount;\\n    }\\n    emit ReservesAdjusted(collateral, amount, increase);\\n  }\\n\\n  /// @notice Internal version of `revokeCollateral`\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (collatInfo.normalizedStables > 0) revert CollateralBacked();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    delete ts.collaterals[collateral];\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 length = collateralListMem.length;\\n    for (uint256 i; i < length - 1; ++i) {\\n      if (collateralListMem[i] == collateral) {\\n        ts.collateralList[i] = collateralListMem[length - 1];\\n        break;\\n      }\\n    }\\n    ts.collateralList.pop();\\n    emit CollateralRevoked(collateral);\\n  }\\n\\n  /// @notice Internal version of `setOracle`\\n  function setOracle(address collateral, bytes memory oracleConfig) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    (,,,, bytes memory hyperparameters) =\\n      abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    if (userDeviation > burnRatioDeviation) revert InvalidParams();\\n    // Checks oracle validity\\n    LibOracle.readMint(oracleConfig);\\n    collatInfo.oracleConfig = oracleConfig;\\n    emit OracleSet(collateral, oracleConfig);\\n  }\\n\\n  /// @notice Internal version of `setWhitelistStatus`\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {\\n    if (whitelistStatus > 1) revert InvalidWhitelistStatus();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (whitelistStatus == 1) {\\n      // Sanity check\\n      LibWhitelist.checkWhitelist(whitelistData, address(this));\\n      collatInfo.whitelistData = whitelistData;\\n    } else {\\n      // If whitelist is revoked, clear the whitelist data\\n      collatInfo.whitelistData = \\\"\\\";\\n    }\\n    collatInfo.onlyWhitelisted = whitelistStatus;\\n    emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GUARDIAN ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `pause` \\u2014 sets the action's live flag to `0`\\n  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance\\n  /// call cannot pass silently\\n  function pause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 0);\\n  }\\n\\n  /// @notice Internal version of `unpause` \\u2014 sets the action's live flag to `1`\\n  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance\\n  /// call cannot pass silently\\n  function unpause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 1);\\n  }\\n\\n  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`\\n  /// to unpause. Reverts on no-op transitions.\\n  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;\\n      if (currentIsLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      if (action == ActionType.Mint) {\\n        collatInfo.isMintLive = targetIsLive;\\n      } else {\\n        collatInfo.isBurnLive = targetIsLive;\\n      }\\n    } else {\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      if (ts.isRedemptionLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      ts.isRedemptionLive = targetIsLive;\\n    }\\n    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);\\n  }\\n\\n  /// @notice Internal version of `setFees`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);\\n    if (mint) {\\n      collatInfo.xFeeMint = xFee;\\n      collatInfo.yFeeMint = yFee;\\n    } else {\\n      collatInfo.xFeeBurn = xFee;\\n      collatInfo.yFeeBurn = yFee;\\n    }\\n    emit FeesSet(collateral, xFee, yFee, mint);\\n  }\\n\\n  /// @notice Internal version of `setRedemptionCurveParams`\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    LibSetters.checkFees(xFee, yFee, ActionType.Redeem);\\n    ts.xRedemptionCurve = xFee;\\n    ts.yRedemptionCurve = yFee;\\n    emit RedemptionCurveParamsSet(xFee, yFee);\\n  }\\n\\n  /// @notice Internal version of `toggleWhitelist`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];\\n    ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;\\n    emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);\\n  }\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a collateral\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    collatInfo.stablecoinCap = stablecoinCap;\\n    emit StablecoinCapSet(collateral, stablecoinCap);\\n  }\\n\\n  /// @notice Internal version of `updatePayees`\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) internal {\\n    if (_payees.length == 0 || _payees.length > MAX_PAYEES) revert InvalidLengths();\\n    if (_payees.length != _shares.length) revert ArrayLengthMismatch();\\n    /// @dev Distribute the fees before updating the fee receivers.\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!_skipRelease) {\\n      uint256 income = ts.tokenP.balanceOf(address(this));\\n      if (income > 0 && ts.payees.length > 0) {\\n        LibSurplus.release(income, ts.payees);\\n      }\\n    }\\n\\n    // Zero out stale shares for old payees\\n    uint256 i = 0;\\n    for (; i < ts.payees.length; ++i) {\\n      ts.shares[ts.payees[i]] = 0;\\n    }\\n    delete ts.payees;\\n    uint256 _totalShares = 0;\\n    i = 0;\\n    for (; i < _payees.length; ++i) {\\n      for (uint256 j = 0; j < i; ++j) {\\n        if (_payees[j] == _payees[i]) revert AlreadyAdded();\\n      }\\n      _totalShares += _addPayee(_payees[i], _shares[i]);\\n    }\\n    ts.totalShares = _totalShares;\\n  }\\n\\n  /// @notice Internal version of `updateSlippageTolerance`\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) internal {\\n    if (slippageTolerance > BASE_9) revert InvalidRate();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.slippageTolerance[collateral] = slippageTolerance;\\n    emit SlippageToleranceUpdated(collateral, slippageTolerance);\\n  }\\n\\n  /// @notice Internal version of `setSwapRouter`\\n  function setSwapRouter(address swapRouter) internal {\\n    if (swapRouter == address(0)) revert ZeroAddress();\\n    s.transmuterStorage().swapRouter = swapRouter;\\n    emit SwapRouterUpdated(swapRouter);\\n  }\\n\\n  /// @notice Internal version of `updateSurplusBufferRatio`\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {\\n    if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.surplusBufferRatio = _surplusBufferRatio;\\n    emit SurplusBufferRatioUpdated(_surplusBufferRatio);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions\\n  function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {\\n    uint256 n = xFee.length;\\n    if (n != yFee.length || n == 0) revert InvalidParams();\\n    if (\\n      // Mint inflexion points should be in [0,BASE_9[\\n      // We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9\\n      // Hence we consider BASE_12 as the max value (100% fees) for yFeeMint\\n      // Burn inflexion points should be in [0,BASE_9] but fees should be constant in\\n      // the first segment [BASE_9, x_{n-1}[\\n      // Redemption inflexion points should be in [0,BASE_9]\\n      (action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))\\n        || (action == ActionType.Burn\\n          && (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1]))))\\n        || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))\\n    ) {\\n      revert InvalidParams();\\n    }\\n\\n    for (uint256 i; i < n - 1; ++i) {\\n      if (\\n        // xFee strictly increasing and yFee increasing for mints\\n        // xFee strictly decreasing and yFee increasing for burns\\n        // xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions\\n        (action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))\\n      ) revert InvalidParams();\\n    }\\n\\n    // If a mint or burn fee is negative, we need to check that accounts atomically minting\\n    // (from any collateral) and then burning cannot get more than their initial value\\n    if (yFee[0] < 0) {\\n      if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 length = collateralListMem.length;\\n      if (action == ActionType.Mint) {\\n        // This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;\\n          if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n      if (action == ActionType.Burn) {\\n        // This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;\\n          if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n    }\\n  }\\n\\n  /// @notice Add a new fee receiver.\\n  /// @param _payee The address of the fee receiver.\\n  /// @param _shares The number of shares assigned to the fee receiver.\\n  function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {\\n    if (_shares == 0) revert ZeroAmount();\\n    // The Parallelizer holds the income being distributed, so a share allocated to itself is handed\\n    // back to `release` as fresh income on the next call. `address(0)` stays valid: `LibSurplus`\\n    // treats it as the sentinel for burning that share.\\n    if (_payee == address(this)) revert InvalidPayee();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n\\n    ts.payees.push(_payee);\\n    ts.shares[_payee] = _shares;\\n    emit PayeeAdded(_payee, _shares);\\n    return _shares;\\n  }\\n}\\n\",\"keccak256\":\"0x45ed1863aec8d20f3659d2b0ea657b629b5c33b71f895ae6775ea72156203197\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
   },
   "userdoc": {
+    "events": {
+      "OracleTargetUpdated(address,uint256,uint256)": {
+        "notice": "Emitted when a MAX target price is ratcheted up by `updateOracle`"
+      }
+    },
     "kind": "user",
     "methods": {
       "addCollateral(address)": {
@@ -836,6 +906,9 @@
       "setOracle(address,bytes)": {
         "notice": "Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations"
       },
+      "setSwapRouter(address)": {
+        "notice": "Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to"
+      },
       "setWhitelistStatus(address,uint8,bytes)": {
         "notice": "Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist"
       },
@@ -859,13 +932,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "hash": "0xbce37119428133e82d039ae2497f7748db8defbf9e335c76a1de956961d42806",
-    "nonce": "0xe3",
+    "hash": "0x56346bc857a5620f551353232eade6a586a959435c3ddf11fbca2265c955fa3d",
+    "nonce": "0x106",
     "origin": "0x66CcEC236bbcE5f1bBd1b2fC0a4014e57A55ad02"
   },
   "receipt": {
-    "blockHash": "0xfaebf09f0e9dbf39b33eea4da0d63616641e561d199600791086d3b85278cba8",
-    "blockNumber": "0x186a799",
-    "transactionIndex": "0x14"
+    "blockHash": "0x5d30189bad2941fffee209c43c6f2ba93062df1e5313c8431aa4290c47923061",
+    "blockNumber": "0x18ef45e",
+    "transactionIndex": "0x67"
   }
 }
\ No newline at end of file

From 1f80ef7137744a34d9806dc21cf1edfc90c4a180 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Thu, 15 Oct 2026 15:22:44 +0400
Subject: [PATCH 32/38] chore(deployments): record the hyperevm facets upgrade
 and GenericRebalancer

SettersGovernor, Getters, Redeemer and RewardHandler are redeployed, the other
facets already had the current bytecode. The GenericRebalancer is deployed
behind the team CooperAccessManager.
---
 .../hyperevm/GenericRebalancer_USDp.json      | 1228 +++++++++++++++++
 deployments/hyperevm/Getters.json             |   46 +-
 deployments/hyperevm/Redeemer.json            |   71 +-
 deployments/hyperevm/RewardHandler.json       |   35 +-
 deployments/hyperevm/SettersGovernor.json     |   97 +-
 5 files changed, 1409 insertions(+), 68 deletions(-)
 create mode 100644 deployments/hyperevm/GenericRebalancer_USDp.json

diff --git a/deployments/hyperevm/GenericRebalancer_USDp.json b/deployments/hyperevm/GenericRebalancer_USDp.json
new file mode 100644
index 0000000..d262330
--- /dev/null
+++ b/deployments/hyperevm/GenericRebalancer_USDp.json
@@ -0,0 +1,1228 @@
+{
+  "address": "0xb3d2115cb61b05f548df21f3c701194a86ee669b",
+  "abi": [
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "initialTokenTransferAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "initialSwapRouter",
+          "type": "address"
+        },
+        {
+          "internalType": "contract ITokenP",
+          "name": "definitivetokenP",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IParallelizer",
+          "name": "definitiveParallelizer",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "initialAuthority",
+          "type": "address"
+        },
+        {
+          "internalType": "contract IERC3156FlashLender",
+          "name": "definitiveFlashloan",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "constructor"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "authority",
+          "type": "address"
+        }
+      ],
+      "name": "AccessManagedInvalidAuthority",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        },
+        {
+          "internalType": "uint32",
+          "name": "delay",
+          "type": "uint32"
+        }
+      ],
+      "name": "AccessManagedRequiredDelay",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "caller",
+          "type": "address"
+        }
+      ],
+      "name": "AccessManagedUnauthorized",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "InvalidParam",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "NotTrusted",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "NotTrustedOrGuardian",
+      "type": "error"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        }
+      ],
+      "name": "SafeERC20FailedOperation",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "SwapError",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
+    {
+      "inputs": [],
+      "name": "ZeroAmount",
+      "type": "error"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "AllowanceReset",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "authority",
+          "type": "address"
+        }
+      ],
+      "name": "AuthorityUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "Recovered",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newSwapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "SwapRouterUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "newTokenTransferAddress",
+          "type": "address"
+        }
+      ],
+      "name": "TokenTransferAddressUpdated",
+      "type": "event"
+    },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": false,
+          "internalType": "address",
+          "name": "trusted",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "bool",
+          "name": "status",
+          "type": "bool"
+        }
+      ],
+      "name": "TrustedToggled",
+      "type": "event"
+    },
+    {
+      "inputs": [],
+      "name": "CALLBACK_SUCCESS",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "addBudget",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "authority",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "budget",
+      "outputs": [
+        {
+          "internalType": "uint256",
+          "name": "",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        }
+      ],
+      "name": "computeRebalanceAmount",
+      "outputs": [
+        {
+          "internalType": "uint8",
+          "name": "increase",
+          "type": "uint8"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "flashloan",
+      "outputs": [
+        {
+          "internalType": "contract IERC3156FlashLender",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "scale",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "extraData",
+          "type": "bytes"
+        }
+      ],
+      "name": "harvest",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "isConsumingScheduledOp",
+      "outputs": [
+        {
+          "internalType": "bytes4",
+          "name": "",
+          "type": "bytes4"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "isTrusted",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "initiator",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "uint256",
+          "name": "fee",
+          "type": "uint256"
+        },
+        {
+          "internalType": "bytes",
+          "name": "data",
+          "type": "bytes"
+        }
+      ],
+      "name": "onFlashLoan",
+      "outputs": [
+        {
+          "internalType": "bytes32",
+          "name": "",
+          "type": "bytes32"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "parallelizer",
+      "outputs": [
+        {
+          "internalType": "contract IParallelizer",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "tokenAddress",
+          "type": "address"
+        },
+        {
+          "internalType": "uint256",
+          "name": "amountToRecover",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "to",
+          "type": "address"
+        }
+      ],
+      "name": "recoverERC20",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "uint256",
+          "name": "amount",
+          "type": "uint256"
+        },
+        {
+          "internalType": "address",
+          "name": "receiver",
+          "type": "address"
+        }
+      ],
+      "name": "removeBudget",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "token",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "spender",
+          "type": "address"
+        }
+      ],
+      "name": "resetAllowance",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newAuthority",
+          "type": "address"
+        }
+      ],
+      "name": "setAuthority",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "newMaxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "name": "setMaxSlippage",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newSwapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "setSwapRouter",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        }
+      ],
+      "name": "setTargetExposure",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "newTokenTransferAddress",
+          "type": "address"
+        }
+      ],
+      "name": "setTokenTransferAddress",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        },
+        {
+          "internalType": "address",
+          "name": "asset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "minExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "overrideExposures",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "name": "setYieldBearingAssetData",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "swapRouter",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "trusted",
+          "type": "address"
+        }
+      ],
+      "name": "toggleTrusted",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "tokenP",
+      "outputs": [
+        {
+          "internalType": "contract ITokenP",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [],
+      "name": "tokenTransferAddress",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "yieldBearingAsset",
+          "type": "address"
+        }
+      ],
+      "name": "updateLimitExposuresYieldAsset",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "name": "yieldBearingData",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "asset",
+          "type": "address"
+        },
+        {
+          "internalType": "uint64",
+          "name": "targetExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "minExposure",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "overrideExposures",
+          "type": "uint64"
+        },
+        {
+          "internalType": "uint64",
+          "name": "maxSlippage",
+          "type": "uint64"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "contractName": "GenericRebalancer",
+  "sourceName": "contracts/helpers/GenericRebalancer.sol",
+  "bytecode": "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",
+  "deployedBytecode": "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",
+  "linkReferences": {},
+  "deployedLinkReferences": {},
+  "immutableReferences": {
+    "10252": [
+      {
+        "length": 32,
+        "start": 629
+      },
+      {
+        "length": 32,
+        "start": 1913
+      },
+      {
+        "length": 32,
+        "start": 2055
+      },
+      {
+        "length": 32,
+        "start": 2191
+      },
+      {
+        "length": 32,
+        "start": 4217
+      },
+      {
+        "length": 32,
+        "start": 5920
+      },
+      {
+        "length": 32,
+        "start": 6053
+      },
+      {
+        "length": 32,
+        "start": 6348
+      },
+      {
+        "length": 32,
+        "start": 6493
+      },
+      {
+        "length": 32,
+        "start": 7129
+      },
+      {
+        "length": 32,
+        "start": 7419
+      }
+    ],
+    "10256": [
+      {
+        "length": 32,
+        "start": 470
+      },
+      {
+        "length": 32,
+        "start": 1497
+      },
+      {
+        "length": 32,
+        "start": 1849
+      },
+      {
+        "length": 32,
+        "start": 2137
+      },
+      {
+        "length": 32,
+        "start": 3715
+      },
+      {
+        "length": 32,
+        "start": 6001
+      },
+      {
+        "length": 32,
+        "start": 8074
+      }
+    ],
+    "11053": [
+      {
+        "length": 32,
+        "start": 538
+      },
+      {
+        "length": 32,
+        "start": 1553
+      },
+      {
+        "length": 32,
+        "start": 8026
+      }
+    ]
+  },
+  "inputSourceName": "project/contracts/helpers/GenericRebalancer.sol",
+  "devdoc": {
+    "author": "Cooper Labs",
+    "custom:contact": "security@cooperlabs.xyz",
+    "details": "Generic contract for trusted callers to adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract, substantially modified: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol",
+    "errors": {
+      "SafeERC20FailedOperation(address)": [
+        {
+          "details": "An operation with an ERC-20 token failed."
+        }
+      ]
+    },
+    "events": {
+      "AuthorityUpdated(address)": {
+        "details": "Authority that manages this contract was updated."
+      }
+    },
+    "kind": "dev",
+    "methods": {
+      "addBudget(uint256,address)": {
+        "params": {
+          "amount": "amount of tokenP to add to the budget",
+          "receiver": "address of the receiver"
+        }
+      },
+      "authority()": {
+        "details": "Returns the current authority."
+      },
+      "computeRebalanceAmount(address)": {
+        "params": {
+          "yieldBearingAsset": "address of the yield bearing asset"
+        },
+        "returns": {
+          "amount": "amount to be rebalanced",
+          "increase": "whether the exposure should be increased"
+        }
+      },
+      "harvest(address,uint256,bytes)": {
+        "details": "This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippageRestricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the collateral oracle, neither of which can be safely exposed to arbitrary callers"
+      },
+      "isConsumingScheduledOp()": {
+        "details": "Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls."
+      },
+      "onFlashLoan(address,address,uint256,uint256,bytes)": {
+        "details": "A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any shortfall between the principal and the tokenP the rebalance minted back",
+        "params": {
+          "amount": "The amount of tokens lent.",
+          "data": "Arbitrary data structure, intended to contain user-defined parameters.",
+          "fee": "The additional amount of tokens to repay.",
+          "initiator": "The initiator of the loan.",
+          "token": "The loan currency."
+        },
+        "returns": {
+          "_0": "The keccak256 hash of \"ERC3156FlashBorrower.onFlashLoan\""
+        }
+      },
+      "recoverERC20(address,uint256,address)": {
+        "params": {
+          "amountToRecover": "amount to recover",
+          "to": "address to send the recovered tokens",
+          "tokenAddress": "address of the token to recover"
+        }
+      },
+      "removeBudget(uint256,address)": {
+        "params": {
+          "amount": "amount of tokenP to remove from the budget",
+          "receiver": "address of the receiver"
+        }
+      },
+      "resetAllowance(address,address)": {
+        "details": "Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing asset's configuration revokes the approvals it created, but this covers a spender that became untrusted for any other reason.",
+        "params": {
+          "spender": "address losing the allowance",
+          "token": "address of the token"
+        }
+      },
+      "setAuthority(address)": {
+        "details": "Transfers control to a new authority. The caller must be the current authority."
+      },
+      "setMaxSlippage(address,uint64)": {
+        "params": {
+          "newMaxSlippage": "new max allowed slippage"
+        }
+      },
+      "setSwapRouter(address)": {
+        "params": {
+          "newSwapRouter": "address of the swap router"
+        }
+      },
+      "setTargetExposure(address,uint64)": {
+        "params": {
+          "targetExposure": "target exposure to the yield bearing asset used",
+          "yieldBearingAsset": "address of the yield bearing asset"
+        }
+      },
+      "setTokenTransferAddress(address)": {
+        "params": {
+          "newTokenTransferAddress": "address of the token transfer contract"
+        }
+      },
+      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": {
+        "params": {
+          "asset": "address of the asset",
+          "maxExposure": "maximum exposure within the Parallelizer to the asset",
+          "minExposure": "minimum exposure within the Parallelizer to the asset",
+          "overrideExposures": "whether limit exposures should be overriden or read onchain through the Parallelizer",
+          "targetExposure": "target exposure to the yieldBearingAsset asset used",
+          "yieldBearingAsset": "address of the yieldBearingAsset"
+        }
+      },
+      "toggleTrusted(address)": {
+        "params": {
+          "trusted": "address to toggle the trusted status"
+        }
+      },
+      "updateLimitExposuresYieldAsset(address)": {
+        "params": {
+          "yieldBearingAsset": "address of the yield bearing asset"
+        }
+      }
+    },
+    "title": "GenericRebalancer",
+    "version": 1
+  },
+  "evm": {
+    "gasEstimates": {
+      "creation": {
+        "codeDepositCost": "2436200",
+        "executionCost": "infinite",
+        "totalCost": "infinite"
+      },
+      "external": {
+        "CALLBACK_SUCCESS()": "240",
+        "addBudget(uint256,address)": "infinite",
+        "authority()": "2407",
+        "budget(address)": "2554",
+        "computeRebalanceAmount(address)": "infinite",
+        "flashloan()": "infinite",
+        "harvest(address,uint256,bytes)": "infinite",
+        "isConsumingScheduledOp()": "2442",
+        "isTrusted(address)": "2612",
+        "onFlashLoan(address,address,uint256,uint256,bytes)": "infinite",
+        "parallelizer()": "infinite",
+        "recoverERC20(address,uint256,address)": "infinite",
+        "removeBudget(uint256,address)": "infinite",
+        "resetAllowance(address,address)": "infinite",
+        "setAuthority(address)": "30486",
+        "setMaxSlippage(address,uint64)": "infinite",
+        "setSwapRouter(address)": "infinite",
+        "setTargetExposure(address,uint64)": "infinite",
+        "setTokenTransferAddress(address)": "infinite",
+        "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": "infinite",
+        "swapRouter()": "2392",
+        "toggleTrusted(address)": "infinite",
+        "tokenP()": "infinite",
+        "tokenTransferAddress()": "2415",
+        "updateLimitExposuresYieldAsset(address)": "infinite",
+        "yieldBearingData(address)": "5001"
+      },
+      "internal": {
+        "_adjustYieldExposure(uint256,uint8,address,address,uint256,enum SwapType,bytes memory)": "infinite",
+        "_recoverResidualInput(address,uint256)": "infinite",
+        "_swapToTokenOut(uint256,address,address,uint256,enum SwapType,bytes memory)": "infinite",
+        "_swapToTokenOutSwap(address,address,uint256,bytes memory)": "infinite",
+        "_swapToTokenOutVault(uint256,address,address,uint256)": "infinite"
+      }
+    }
+  },
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialTokenTransferAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialSwapRouter\",\"type\":\"address\"},{\"internalType\":\"contract ITokenP\",\"name\":\"definitivetokenP\",\"type\":\"address\"},{\"internalType\":\"contract IParallelizer\",\"name\":\"definitiveParallelizer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialAuthority\",\"type\":\"address\"},{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"definitiveFlashloan\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AccessManagedInvalidAuthority\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"delay\",\"type\":\"uint32\"}],\"name\":\"AccessManagedRequiredDelay\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrustedOrGuardian\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SwapError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"AllowanceReset\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"authority\",\"type\":\"address\"}],\"name\":\"AuthorityUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"TokenTransferAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"status\",\"type\":\"bool\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"CALLBACK_SUCCESS\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"addBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"authority\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"budget\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"computeRebalanceAmount\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"increase\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"flashloan\",\"outputs\":[{\"internalType\":\"contract IERC3156FlashLender\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"scale\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraData\",\"type\":\"bytes\"}],\"name\":\"harvest\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initiator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"fee\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onFlashLoan\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"parallelizer\",\"outputs\":[{\"internalType\":\"contract IParallelizer\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountToRecover\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"}],\"name\":\"removeBudget\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"resetAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAuthority\",\"type\":\"address\"}],\"name\":\"setAuthority\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"newMaxSlippage\",\"type\":\"uint64\"}],\"name\":\"setMaxSlippage\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newSwapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"}],\"name\":\"setTargetExposure\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newTokenTransferAddress\",\"type\":\"address\"}],\"name\":\"setTokenTransferAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxSlippage\",\"type\":\"uint64\"}],\"name\":\"setYieldBearingAssetData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"swapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"trusted\",\"type\":\"address\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenTransferAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"yieldBearingAsset\",\"type\":\"address\"}],\"name\":\"updateLimitExposuresYieldAsset\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"yieldBearingData\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"asset\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"targetExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"minExposure\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"overrideExposures\",\"type\":\"uint64\"},{\"internalType\":\"uint64\",\"name\":\"maxSlippage\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"Generic contract for trusted callers to adjust the reserves of Angle ParallelizerThis contract is an authorized fork of Angle's GenericHarvester contract, substantially modified: https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"events\":{\"AuthorityUpdated(address)\":{\"details\":\"Authority that manages this contract was updated.\"}},\"kind\":\"dev\",\"methods\":{\"addBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to add to the budget\",\"receiver\":\"address of the receiver\"}},\"authority()\":{\"details\":\"Returns the current authority.\"},\"computeRebalanceAmount(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"},\"returns\":{\"amount\":\"amount to be rebalanced\",\"increase\":\"whether the exposure should be increased\"}},\"harvest(address,uint256,bytes)\":{\"details\":\"This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up some yieldBearingAsset that can then be used for people looking to burn deposit tokensDue to potential transaction fees within the Parallelizer, this function doesn't exactly bring `yieldBearingAsset` to the target exposurescale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest, it is used to lower the amount of the asset to harvest for example to have a lower slippageRestricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the collateral oracle, neither of which can be safely exposed to arbitrary callers\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"onFlashLoan(address,address,uint256,uint256,bytes)\":{\"details\":\"A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any shortfall between the principal and the tokenP the rebalance minted back\",\"params\":{\"amount\":\"The amount of tokens lent.\",\"data\":\"Arbitrary data structure, intended to contain user-defined parameters.\",\"fee\":\"The additional amount of tokens to repay.\",\"initiator\":\"The initiator of the loan.\",\"token\":\"The loan currency.\"},\"returns\":{\"_0\":\"The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\"}},\"recoverERC20(address,uint256,address)\":{\"params\":{\"amountToRecover\":\"amount to recover\",\"to\":\"address to send the recovered tokens\",\"tokenAddress\":\"address of the token to recover\"}},\"removeBudget(uint256,address)\":{\"params\":{\"amount\":\"amount of tokenP to remove from the budget\",\"receiver\":\"address of the receiver\"}},\"resetAllowance(address,address)\":{\"details\":\"Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing asset's configuration revokes the approvals it created, but this covers a spender that became untrusted for any other reason.\",\"params\":{\"spender\":\"address losing the allowance\",\"token\":\"address of the token\"}},\"setAuthority(address)\":{\"details\":\"Transfers control to a new authority. The caller must be the current authority.\"},\"setMaxSlippage(address,uint64)\":{\"params\":{\"newMaxSlippage\":\"new max allowed slippage\"}},\"setSwapRouter(address)\":{\"params\":{\"newSwapRouter\":\"address of the swap router\"}},\"setTargetExposure(address,uint64)\":{\"params\":{\"targetExposure\":\"target exposure to the yield bearing asset used\",\"yieldBearingAsset\":\"address of the yield bearing asset\"}},\"setTokenTransferAddress(address)\":{\"params\":{\"newTokenTransferAddress\":\"address of the token transfer contract\"}},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)\":{\"params\":{\"asset\":\"address of the asset\",\"maxExposure\":\"maximum exposure within the Parallelizer to the asset\",\"minExposure\":\"minimum exposure within the Parallelizer to the asset\",\"overrideExposures\":\"whether limit exposures should be overriden or read onchain through the Parallelizer\",\"targetExposure\":\"target exposure to the yieldBearingAsset asset used\",\"yieldBearingAsset\":\"address of the yieldBearingAsset\"}},\"toggleTrusted(address)\":{\"params\":{\"trusted\":\"address to toggle the trusted status\"}},\"updateLimitExposuresYieldAsset(address)\":{\"params\":{\"yieldBearingAsset\":\"address of the yield bearing asset\"}}},\"title\":\"GenericRebalancer\",\"version\":1},\"userdoc\":{\"events\":{\"SwapRouterUpdated(address)\":{\"notice\":\"Event emitted when the swap router is updated\"},\"TokenTransferAddressUpdated(address)\":{\"notice\":\"Event emitted when the token proxy is updated\"}},\"kind\":\"user\",\"methods\":{\"addBudget(uint256,address)\":{\"notice\":\"Add budget to be spent by the receiver during the flashloan\"},\"budget(address)\":{\"notice\":\"Budget of tokenP available for each users\"},\"computeRebalanceAmount(address)\":{\"notice\":\"Compute the amount needed to rebalance the Parallelizer\"},\"flashloan()\":{\"notice\":\"Parallel stablecoin flashloan contract\"},\"harvest(address,uint256,bytes)\":{\"notice\":\"Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset\"},\"isTrusted(address)\":{\"notice\":\"trusted addresses that can update target exposure and do others non critical operations\"},\"parallelizer()\":{\"notice\":\"Reference to the `parallelizer` implementation this contract aims at rebalancing\"},\"recoverERC20(address,uint256,address)\":{\"notice\":\"Recover ERC20 tokens\"},\"removeBudget(uint256,address)\":{\"notice\":\"Remove budget from the owner and send it to the receiver\"},\"resetAllowance(address,address)\":{\"notice\":\"Set an allowance this contract granted back to zero\"},\"setMaxSlippage(address,uint64)\":{\"notice\":\"Set the max allowed slippage\"},\"setSwapRouter(address)\":{\"notice\":\"Set the swap router\"},\"setTargetExposure(address,uint64)\":{\"notice\":\"Set the target exposure of a yield bearing asset\"},\"setTokenTransferAddress(address)\":{\"notice\":\"Set the token transfer address\"},\"setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)\":{\"notice\":\"Set the yieldBearingAsset data\"},\"swapRouter()\":{\"notice\":\"address of the router/aggregator\"},\"toggleTrusted(address)\":{\"notice\":\"Toggle the trusted status of an address\"},\"tokenP()\":{\"notice\":\"TokenP handled by the `parallelizer` of interest\"},\"tokenTransferAddress()\":{\"notice\":\"address to approve to transfer tokens to\"},\"updateLimitExposuresYieldAsset(address)\":{\"notice\":\"Set the limit exposures to the asset linked to the yield bearing asset\"},\"yieldBearingData(address)\":{\"notice\":\"Data associated to a yield bearing asset\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/helpers/GenericRebalancer.sol\":\"GenericRebalancer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManaged.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManaged {\\n    /**\\n     * @dev Authority that manages this contract was updated.\\n     */\\n    event AuthorityUpdated(address authority);\\n\\n    error AccessManagedUnauthorized(address caller);\\n    error AccessManagedRequiredDelay(address caller, uint32 delay);\\n    error AccessManagedInvalidAuthority(address authority);\\n\\n    /**\\n     * @dev Returns the current authority.\\n     */\\n    function authority() external view returns (address);\\n\\n    /**\\n     * @dev Transfers control to a new authority. The caller must be the current authority.\\n     */\\n    function setAuthority(address) external;\\n\\n    /**\\n     * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n     * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n     * attacker controlled calls.\\n     */\\n    function isConsumingScheduledOp() external view returns (bytes4);\\n}\\n\",\"keccak256\":\"0x1121e070554cffc6d536f658332a1a3d65fb2ea5573cd774f4ecbd02a2fcf4b7\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashBorrower.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashBorrower.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashBorrower, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashBorrower {\\n    /**\\n     * @dev Receive a flash loan.\\n     * @param initiator The initiator of the loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param fee The additional amount of tokens to repay.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     * @return The keccak256 hash of \\\"ERC3156FlashBorrower.onFlashLoan\\\"\\n     */\\n    function onFlashLoan(\\n        address initiator,\\n        address token,\\n        uint256 amount,\\n        uint256 fee,\\n        bytes calldata data\\n    ) external returns (bytes32);\\n}\\n\",\"keccak256\":\"0x4e4b982b56b50290dd1dcaa2fef1178b1574dfc7c0f0a8ef9cb68a207d72582e\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC3156FlashLender.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC3156FlashLender.sol)\\n\\npragma solidity >=0.5.0;\\n\\nimport {IERC3156FlashBorrower} from \\\"./IERC3156FlashBorrower.sol\\\";\\n\\n/**\\n * @dev Interface of the ERC-3156 FlashLender, as defined in\\n * https://eips.ethereum.org/EIPS/eip-3156[ERC-3156].\\n */\\ninterface IERC3156FlashLender {\\n    /**\\n     * @dev The amount of currency available to be lended.\\n     * @param token The loan currency.\\n     * @return The amount of `token` that can be borrowed.\\n     */\\n    function maxFlashLoan(address token) external view returns (uint256);\\n\\n    /**\\n     * @dev The fee to be charged for a given loan.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @return The amount of `token` to be charged for the loan, on top of the returned principal.\\n     */\\n    function flashFee(address token, uint256 amount) external view returns (uint256);\\n\\n    /**\\n     * @dev Initiate a flash loan.\\n     * @param receiver The receiver of the tokens in the loan, and the receiver of the callback.\\n     * @param token The loan currency.\\n     * @param amount The amount of tokens lent.\\n     * @param data Arbitrary data structure, intended to contain user-defined parameters.\\n     */\\n    function flashLoan(\\n        IERC3156FlashBorrower receiver,\\n        address token,\\n        uint256 amount,\\n        bytes calldata data\\n    ) external returns (bool);\\n}\\n\",\"keccak256\":\"0x218d708e7d8df417db24a497727eefb7772e61c7cde3886fc42bbcb6aafa6947\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n    function _msgSender() internal view virtual returns (address) {\\n        return msg.sender;\\n    }\\n\\n    function _msgData() internal view virtual returns (bytes calldata) {\\n        return msg.data;\\n    }\\n\\n    function _contextSuffixLength() internal view virtual returns (uint256) {\\n        return 0;\\n    }\\n}\\n\",\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/helpers/BaseRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { AccessManaged } from \\\"../utils/AccessManaged.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport \\\"contracts/interfaces/IRebalancer.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nstruct YieldBearingParams {\\n  // Address of the asset used to mint the yield bearing asset\\n  address asset;\\n  // Target exposure to the collateral yield bearing asset used\\n  uint64 targetExposure;\\n  // Maximum exposure within the Parallelizer to the deposit asset\\n  uint64 maxExposure;\\n  // Minimum exposure within the Parallelizer to the deposit asset\\n  uint64 minExposure;\\n  // Whether limit exposures should be overriden or read onchain through the Parallelizer\\n  // This value should be 1 to override exposures or 2 if these shouldn't be overriden\\n  uint64 overrideExposures;\\n  // Maximum slippage when dealing with the Parallelizer, bounded below 1e9 so uint64 leaves the\\n  // struct packed in two slots\\n  uint64 maxSlippage;\\n}\\n\\n/// @title BaseRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Abstract contract for a rebalancer that aims at rebalancing a Parallelizer\\n/// @dev This contract is an authorized fork of Angle's BaseHarvester contract, substantially modified:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/BaseHarvester.sol\\nabstract contract BaseRebalancer is IRebalancer, AccessManaged {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       MODIFIERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrusted() {\\n    if (!isTrusted[msg.sender]) revert NotTrusted();\\n    _;\\n  }\\n\\n  /**\\n   * @notice Checks whether the `msg.sender` is trusted or guardian to update\\n   * target exposure and do others non critical operations\\n   */\\n  modifier onlyTrustedOrRestricted() {\\n    if (!isTrusted[msg.sender] && !_checkCanCall(_msgSender(), _msgData())) {\\n      revert NotTrustedOrGuardian();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       VARIABLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reference to the `parallelizer` implementation this contract aims at rebalancing\\n  IParallelizer public immutable parallelizer;\\n  /// @notice TokenP handled by the `parallelizer` of interest\\n  ITokenP public immutable tokenP;\\n  /// @notice Data associated to a yield bearing asset\\n  mapping(address => YieldBearingParams) public yieldBearingData;\\n  /// @notice trusted addresses that can update target exposure and do others non critical operations\\n  mapping(address => bool) public isTrusted;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EVENTS                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  event Recovered(address token, uint256 amount, address to);\\n  event TrustedToggled(address trusted, bool status);\\n  event AllowanceReset(address indexed token, address indexed spender);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                       CONSTRUCTOR\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialAuthority,\\n    ITokenP definitiveTokenP,\\n    IParallelizer definitiveParallelizer\\n  )\\n    AccessManaged(initialAuthority)\\n  {\\n    tokenP = definitiveTokenP;\\n    parallelizer = definitiveParallelizer;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        GUARDIAN FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the yieldBearingAsset data\\n   * @param yieldBearingAsset address of the yieldBearingAsset\\n   * @param asset address of the asset\\n   * @param targetExposure target exposure to the yieldBearingAsset asset used\\n   * @param minExposure minimum exposure within the Parallelizer to the asset\\n   * @param maxExposure maximum exposure within the Parallelizer to the asset\\n   * @param overrideExposures whether limit exposures should be overriden or read onchain through the Parallelizer\\n   */\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    external\\n    restricted\\n  {\\n    _setYieldBearingAssetData(\\n      yieldBearingAsset, asset, targetExposure, minExposure, maxExposure, overrideExposures, maxSlippage\\n    );\\n  }\\n\\n  /**\\n   * @notice Set the limit exposures to the asset linked to the yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   */\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) public virtual {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    if (yieldBearingInfo.overrideExposures == 2) {\\n      _updateLimitExposuresYieldAsset(yieldBearingInfo.asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /**\\n   * @notice Set the max allowed slippage\\n   * @param newMaxSlippage new max allowed slippage\\n   */\\n  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external restricted {\\n    _setMaxSlippage(yieldBearingAsset, newMaxSlippage);\\n  }\\n\\n  /**\\n   * @notice Toggle the trusted status of an address\\n   * @param trusted address to toggle the trusted status\\n   */\\n  function toggleTrusted(address trusted) external restricted {\\n    emit TrustedToggled(trusted, isTrusted[trusted]);\\n    isTrusted[trusted] = !isTrusted[trusted];\\n  }\\n\\n  /**\\n   * @notice Recover ERC20 tokens\\n   * @param tokenAddress address of the token to recover\\n   * @param amountToRecover amount to recover\\n   * @param to address to send the recovered tokens\\n   */\\n  function recoverERC20(address tokenAddress, uint256 amountToRecover, address to) external restricted {\\n    emit Recovered(tokenAddress, amountToRecover, to);\\n    IERC20(tokenAddress).safeTransfer(to, amountToRecover);\\n  }\\n\\n  /**\\n   * @notice Set an allowance this contract granted back to zero\\n   * @param token address of the token\\n   * @param spender address losing the allowance\\n   * @dev Rebalancing grants unlimited allowances that are never reduced. Rotating a yield bearing\\n   * asset's configuration revokes the approvals it created, but this covers a spender that became\\n   * untrusted for any other reason.\\n   */\\n  function resetAllowance(address token, address spender) external restricted {\\n    IERC20(token).forceApprove(spender, 0);\\n    emit AllowanceReset(token, spender);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        TRUSTED FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the target exposure of a yield bearing asset\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @param targetExposure target exposure to the yield bearing asset used\\n   */\\n  function setTargetExposure(address yieldBearingAsset, uint64 targetExposure) external onlyTrustedOrRestricted {\\n    yieldBearingData[yieldBearingAsset].targetExposure = targetExposure;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Compute the amount needed to rebalance the Parallelizer\\n   * @param yieldBearingAsset address of the yield bearing asset\\n   * @return increase whether the exposure should be increased\\n   * @return amount amount to be rebalanced\\n   */\\n  function computeRebalanceAmount(address yieldBearingAsset) external view returns (uint8 increase, uint256 amount) {\\n    return _computeRebalanceAmount(yieldBearingAsset, yieldBearingData[yieldBearingAsset]);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        INTERNAL FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _computeRebalanceAmount(\\n    address yieldBearingAsset,\\n    YieldBearingParams memory yieldBearingInfo\\n  )\\n    internal\\n    view\\n    returns (uint8 increase, uint256 amount)\\n  {\\n    (uint256 stablecoinsFromYieldBearingAsset, uint256 stablecoinsIssued) =\\n      parallelizer.getIssuedByCollateral(yieldBearingAsset);\\n    (uint256 stablecoinsFromAsset,) = parallelizer.getIssuedByCollateral(yieldBearingInfo.asset);\\n    uint256 targetExposureScaled = yieldBearingInfo.targetExposure * stablecoinsIssued;\\n    if (stablecoinsFromYieldBearingAsset * 1e9 > targetExposureScaled) {\\n      // Need to decrease exposure to yield bearing asset\\n      amount = stablecoinsFromYieldBearingAsset - targetExposureScaled / 1e9;\\n      uint256 maxValueScaled = yieldBearingInfo.maxExposure * stablecoinsIssued;\\n      // These checks assume that there are no transaction fees on the stablecoin->collateral conversion and so\\n      // it's still possible that exposure goes above the max exposure in some rare cases\\n      if (stablecoinsFromAsset * 1e9 > maxValueScaled) {\\n        amount = 0;\\n      } else if ((stablecoinsFromAsset + amount) * 1e9 > maxValueScaled) {\\n        amount = maxValueScaled / 1e9 - stablecoinsFromAsset;\\n      }\\n    } else {\\n      // In this case, exposure after the operation might remain slightly below the targetExposure as less\\n      // collateral may be obtained by burning stablecoins for the yield asset and unwrapping it\\n      increase = 1;\\n      amount = targetExposureScaled / 1e9 - stablecoinsFromYieldBearingAsset;\\n      uint256 minValueScaled = yieldBearingInfo.minExposure * stablecoinsIssued;\\n      if (stablecoinsFromAsset * 1e9 < minValueScaled) {\\n        amount = 0;\\n      } else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9) {\\n        amount = stablecoinsFromAsset - minValueScaled / 1e9;\\n      }\\n    }\\n  }\\n\\n  function _setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address asset,\\n    uint64 targetExposure,\\n    uint64 minExposure,\\n    uint64 maxExposure,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    internal\\n    virtual\\n  {\\n    YieldBearingParams storage yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    address previousAsset = yieldBearingInfo.asset;\\n    // Allowances are granted without expiry, so the outgoing asset would keep the yield bearing\\n    // vault authorised over any of it later held here\\n    if (previousAsset != address(0) && previousAsset != asset) {\\n      IERC20(previousAsset).forceApprove(yieldBearingAsset, 0);\\n      emit AllowanceReset(previousAsset, yieldBearingAsset);\\n      _revokeAssetAllowances(yieldBearingAsset, previousAsset);\\n    }\\n    yieldBearingInfo.asset = asset;\\n    if (targetExposure >= 1e9) revert InvalidParam();\\n    if (maxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingInfo.targetExposure = targetExposure;\\n    yieldBearingInfo.overrideExposures = overrideExposures;\\n    yieldBearingInfo.maxSlippage = maxSlippage;\\n    if (overrideExposures == 1) {\\n      if (maxExposure >= 1e9 || minExposure >= maxExposure) revert InvalidParam();\\n      yieldBearingInfo.maxExposure = maxExposure;\\n      yieldBearingInfo.minExposure = minExposure;\\n    } else {\\n      yieldBearingInfo.overrideExposures = 2;\\n      _updateLimitExposuresYieldAsset(asset, yieldBearingInfo);\\n    }\\n  }\\n\\n  /// @notice Lets a rebalancer revoke the allowances it granted over an asset being rotated out\\n  function _revokeAssetAllowances(address yieldBearingAsset, address previousAsset) internal virtual { }\\n\\n  function _updateLimitExposuresYieldAsset(\\n    address asset,\\n    YieldBearingParams storage yieldBearingInfo\\n  )\\n    internal\\n    virtual\\n  {\\n    uint64[] memory xFeeMint;\\n    (xFeeMint,) = parallelizer.getCollateralMintFees(asset);\\n    uint256 length = xFeeMint.length;\\n    if (length <= 1) yieldBearingInfo.maxExposure = 1e9;\\n    else yieldBearingInfo.maxExposure = xFeeMint[length - 2];\\n\\n    uint64[] memory xFeeBurn;\\n    (xFeeBurn,) = parallelizer.getCollateralBurnFees(asset);\\n    length = xFeeBurn.length;\\n    if (length <= 1) yieldBearingInfo.minExposure = 0;\\n    else yieldBearingInfo.minExposure = xFeeBurn[length - 2];\\n  }\\n\\n  function _setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) internal virtual {\\n    if (newMaxSlippage >= 1e9) revert InvalidParam();\\n    yieldBearingData[yieldBearingAsset].maxSlippage = newMaxSlippage;\\n  }\\n\\n  function _scaleAmountBasedOnDecimals(\\n    uint256 decimalsTokenIn,\\n    uint256 decimalsTokenOut,\\n    uint256 amountIn,\\n    bool assetIn\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (decimalsTokenIn > decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn /= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      } else {\\n        amountIn *= 10 ** (decimalsTokenIn - decimalsTokenOut);\\n      }\\n    } else if (decimalsTokenIn < decimalsTokenOut) {\\n      if (assetIn) {\\n        amountIn *= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      } else {\\n        amountIn /= 10 ** (decimalsTokenOut - decimalsTokenIn);\\n      }\\n    }\\n    return amountIn;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPER                                                      \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function _adjustAllowance(address token, address sender, uint256 amountIn) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), sender);\\n    if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);\\n  }\\n}\\n\",\"keccak256\":\"0x5d05479be1ac7d1dc738cb8fc2e539c82e88a2191dee278cc74fd647eed17ebc\",\"license\":\"GPL-3.0\"},\"project/contracts/helpers/GenericRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\nimport { IERC3156FlashBorrower } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashBorrower.sol\\\";\\nimport { IERC3156FlashLender } from \\\"@openzeppelin/contracts/interfaces/IERC3156FlashLender.sol\\\";\\nimport { RouterSwapper } from \\\"@helpers/RouterSwapper.sol\\\";\\n\\nimport { IParallelizer } from \\\"contracts/interfaces/IParallelizer.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IERC4626 } from \\\"contracts/interfaces/external/IERC4626.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\nimport { BaseRebalancer, YieldBearingParams } from \\\"./BaseRebalancer.sol\\\";\\n\\nenum SwapType {\\n  VAULT,\\n  SWAP\\n}\\n\\n/// @title GenericRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Generic contract for trusted callers to adjust the reserves of Angle Parallelizer\\n/// @dev This contract is an authorized fork of Angle's GenericHarvester contract, substantially modified:\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/helpers/GenericHarvester.sol\\ncontract GenericRebalancer is BaseRebalancer, IERC3156FlashBorrower, RouterSwapper {\\n  using SafeCast for uint256;\\n  using SafeERC20 for IERC20;\\n\\n  bytes32 public constant CALLBACK_SUCCESS = keccak256(\\\"ERC3156FlashBorrower.onFlashLoan\\\");\\n\\n  /// @notice Parallel stablecoin flashloan contract\\n  IERC3156FlashLender public immutable flashloan;\\n  /// @notice Budget of tokenP available for each users\\n  mapping(address => uint256) public budget;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INITIALIZATION                                                  \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  constructor(\\n    address initialTokenTransferAddress,\\n    address initialSwapRouter,\\n    ITokenP definitivetokenP,\\n    IParallelizer definitiveParallelizer,\\n    address initialAuthority,\\n    IERC3156FlashLender definitiveFlashloan\\n  )\\n    RouterSwapper(initialSwapRouter, initialTokenTransferAddress)\\n    BaseRebalancer(initialAuthority, definitivetokenP, definitiveParallelizer)\\n  {\\n    if (address(definitiveFlashloan) == address(0)) revert ZeroAddress();\\n    flashloan = definitiveFlashloan;\\n\\n    IERC20(tokenP).approve(address(definitiveFlashloan), type(uint256).max);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        BUDGET HANDLING\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Add budget to be spent by the receiver during the flashloan\\n   * @param amount amount of tokenP to add to the budget\\n   * @param receiver address of the receiver\\n   */\\n  function addBudget(uint256 amount, address receiver) public virtual {\\n    budget[receiver] += amount;\\n\\n    IERC20(tokenP).safeTransferFrom(msg.sender, address(this), amount);\\n  }\\n\\n  /**\\n   * @notice Remove budget from the owner and send it to the receiver\\n   * @param amount amount of tokenP to remove from the budget\\n   * @param receiver address of the receiver\\n   */\\n  function removeBudget(uint256 amount, address receiver) public virtual {\\n    budget[msg.sender] -= amount; // Will revert if not enough funds\\n\\n    IERC20(tokenP).safeTransfer(receiver, amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        HARVEST\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure\\n  ///  to this yieldBearingAsset\\n  /// @dev This transaction either reduces the exposure to `yieldBearingAsset` in the Parallelizer or frees up\\n  /// some yieldBearingAsset that can then be used for people looking to burn deposit tokens\\n  /// @dev Due to potential transaction fees within the Parallelizer, this function doesn't exactly bring\\n  /// `yieldBearingAsset` to the target exposure\\n  /// @dev scale is a number between 0 and 1e9 that represents the proportion of the tokenP to harvest,\\n  /// it is used to lower the amount of the asset to harvest for example to have a lower slippage\\n  /// @dev Restricted to trusted callers: the flow forwards caller-supplied router calldata and refreshes the\\n  /// collateral oracle, neither of which can be safely exposed to arbitrary callers\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) public virtual onlyTrusted {\\n    if (scale > 1e9) revert InvalidParam();\\n    updateLimitExposuresYieldAsset(yieldBearingAsset);\\n    YieldBearingParams memory yieldBearingInfo = yieldBearingData[yieldBearingAsset];\\n    (uint8 increase, uint256 amount) = _computeRebalanceAmount(yieldBearingAsset, yieldBearingInfo);\\n    amount = (amount * scale) / 1e9;\\n    if (amount == 0) revert ZeroAmount();\\n    (SwapType swapType, bytes memory data) = abi.decode(extraData, (SwapType, bytes));\\n    try parallelizer.updateOracle(yieldBearingAsset) { } catch { }\\n    _adjustYieldExposure(\\n      amount,\\n      increase,\\n      yieldBearingAsset,\\n      yieldBearingInfo.asset,\\n      (amount * (1e9 - yieldBearingInfo.maxSlippage)) / 1e9,\\n      swapType,\\n      data\\n    );\\n  }\\n\\n  /// @inheritdoc IERC3156FlashBorrower\\n  /// @dev A non-zero lender fee is charged to the budget of the address that called `harvest`, alongside any\\n  /// shortfall between the principal and the tokenP the rebalance minted back\\n  function onFlashLoan(\\n    address initiator,\\n    address,\\n    uint256 amount,\\n    uint256 fee,\\n    bytes calldata data\\n  )\\n    public\\n    virtual\\n    returns (bytes32)\\n  {\\n    if (msg.sender != address(flashloan) || initiator != address(this)) revert NotTrusted();\\n    address sender;\\n    uint256 typeAction;\\n    uint256 minAmountOut;\\n    SwapType swapType;\\n    bytes memory callData;\\n    address tokenOut;\\n    address tokenIn;\\n    {\\n      address yieldBearingAsset;\\n      address asset;\\n      (sender, typeAction, yieldBearingAsset, asset, minAmountOut, swapType, callData) =\\n        abi.decode(data, (address, uint256, address, address, uint256, SwapType, bytes));\\n      if (typeAction == 1) {\\n        // Increase yield exposure action: we bring in the yield bearing asset\\n        tokenOut = yieldBearingAsset;\\n        tokenIn = asset;\\n      } else {\\n        // Decrease yield exposure action: we bring in the deposit asset\\n        tokenIn = yieldBearingAsset;\\n        tokenOut = asset;\\n      }\\n    }\\n    uint256 tokenInBalanceBefore = IERC20(tokenIn).balanceOf(address(this));\\n\\n    uint256 amountOut =\\n      parallelizer.swapExactInput(amount, 0, address(tokenP), tokenIn, address(this), block.timestamp);\\n    // The principal is spent, what the lender will pull back is the principal plus its fee\\n    amount += fee;\\n\\n    // Swap to tokenOut\\n    amountOut = _swapToTokenOut(typeAction, tokenIn, tokenOut, amountOut, swapType, callData);\\n\\n    _adjustAllowance(tokenOut, address(parallelizer), amountOut);\\n    uint256 amountStableOut =\\n      parallelizer.swapExactInput(amountOut, minAmountOut, tokenOut, address(tokenP), address(this), block.timestamp);\\n\\n    amountStableOut += _recoverResidualInput(tokenIn, tokenInBalanceBefore);\\n\\n    if (amount > amountStableOut) {\\n      budget[sender] -= amount - amountStableOut; // Will revert if not enough funds\\n    } else if (amountStableOut > amount) {\\n      budget[sender] += amountStableOut - amount;\\n    }\\n    return CALLBACK_SUCCESS;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SETTERS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the token transfer contract\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress) public override restricted {\\n    super.setTokenTransferAddress(newTokenTransferAddress);\\n  }\\n\\n  /**\\n   * @notice Set the swap router\\n   * @param newSwapRouter address of the swap router\\n   */\\n  function setSwapRouter(address newSwapRouter) public override restricted {\\n    super.setSwapRouter(newSwapRouter);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNALS                                                     \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Burns `amountStablecoins` for one yieldBearing asset, swap for asset then mints deposit tokens\\n  /// from the proceeds of the swap.\\n  /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means\\n  /// burning tokenP for the deposit asset, swapping for the yield bearing asset, then minting the tokenP\\n  /// @dev This function reverts if the second tokenP mint gives less than `minAmountOut` of ag tokens\\n  /// @dev This function reverts if the swap slippage is higher than `maxSlippage`\\n  function _adjustYieldExposure(\\n    uint256 amountStablecoins,\\n    uint8 increase,\\n    address yieldBearingAsset,\\n    address asset,\\n    uint256 minAmountOut,\\n    SwapType swapType,\\n    bytes memory extraData\\n  )\\n    internal\\n  {\\n    flashloan.flashLoan(\\n      IERC3156FlashBorrower(address(this)),\\n      address(tokenP),\\n      amountStablecoins,\\n      abi.encode(msg.sender, increase, yieldBearingAsset, asset, minAmountOut, swapType, extraData)\\n    );\\n  }\\n\\n  /**\\n   * @dev Returns any input the route did not consume to the Parallelizer\\n   * @param tokenIn address of the token offered to the route\\n   * @param balanceBefore balance of `tokenIn` held before the operation\\n   * @return the tokenP obtained from the remainder, zero when the route consumed everything\\n   *\\n   * Router calldata is built off chain while the input is sized on chain, so a route can consume\\n   * less than was offered. Returning the remainder keeps it inside the Parallelizer's accounting\\n   * instead of stranding it here, and it settles with the rest of the operation.\\n   */\\n  function _recoverResidualInput(address tokenIn, uint256 balanceBefore) internal returns (uint256) {\\n    uint256 balanceAfter = IERC20(tokenIn).balanceOf(address(this));\\n    if (balanceAfter <= balanceBefore) return 0;\\n    uint256 residual = balanceAfter - balanceBefore;\\n    _adjustAllowance(tokenIn, address(parallelizer), residual);\\n    return parallelizer.swapExactInput(residual, 0, tokenIn, address(tokenP), address(this), block.timestamp);\\n  }\\n\\n  function _swapToTokenOut(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    SwapType swapType,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (swapType == SwapType.SWAP) {\\n      amountOut = _swapToTokenOutSwap(tokenIn, tokenOut, amount, callData);\\n    } else if (swapType == SwapType.VAULT) {\\n      amountOut = _swapToTokenOutVault(typeAction, tokenIn, tokenOut, amount);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap token using the router/aggregator\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _swapToTokenOutSwap(\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount,\\n    bytes memory callData\\n  )\\n    internal\\n    returns (uint256)\\n  {\\n    uint256 balance = IERC20(tokenOut).balanceOf(address(this));\\n\\n    address[] memory tokens = new address[](1);\\n    tokens[0] = tokenIn;\\n    bytes[] memory callDatas = new bytes[](1);\\n    callDatas[0] = callData;\\n    uint256[] memory amounts = new uint256[](1);\\n    amounts[0] = amount;\\n    _swap(tokens, callDatas, amounts);\\n    // A route that consumed less than offered would otherwise leave the difference approved\\n    IERC20(tokenIn).forceApprove(tokenTransferAddress, 0);\\n\\n    return IERC20(tokenOut).balanceOf(address(this)) - balance;\\n  }\\n\\n  /**\\n   * @dev Deposit or redeem the vault asset\\n   * @param typeAction 1 for deposit, 2 for redeem\\n   * @param tokenIn address of the token to swap\\n   * @param tokenOut address of the token to receive\\n   * @param amount amount of token to swap\\n   */\\n  function _swapToTokenOutVault(\\n    uint256 typeAction,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amount\\n  )\\n    internal\\n    returns (uint256 amountOut)\\n  {\\n    if (typeAction == 1) {\\n      // Granting allowance with the yieldBearingAsset for the vault asset\\n      _adjustAllowance(tokenIn, tokenOut, amount);\\n      amountOut = IERC4626(tokenOut).deposit(amount, address(this));\\n    } else {\\n      amountOut = IERC4626(tokenIn).redeem(amount, address(this), address(this));\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0xe10b65b2a75ead0d938a2282cf478e94ea425adb38a03ca077fa0422ec2d322c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IDiamondCut.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IDiamondCut\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondCut.sol by mudgen\\n/// @dev This interface is an authorized fork of Angle's `IDiamondCut` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IDiamondCut.sol\\ninterface IDiamondCut {\\n  /// @notice Add/replace/remove any number of functions and optionally execute a function with delegatecall\\n  /// @param _diamondCut Contains the facet addresses and function selectors\\n  /// @param _init The address of the contract or facet to execute _calldata\\n  /// @param _calldata A function call, including function selector and arguments, executed with delegatecall on\\n  /// _init\\n  function diamondCut(FacetCut[] calldata _diamondCut, address _init, bytes calldata _calldata) external;\\n}\\n\",\"keccak256\":\"0x08a01f77b740f7da424f0ea27a6a292f9e292058e23d1fe960d2d19a44496c7b\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondEtherscan.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IDiamondEtherscan\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface IDiamondEtherscan {\\n  /// @notice Sets a dummy implementation with the same layout at the diamond proxy contract with all its facets\\n  function setDummyImplementation(address _implementation) external;\\n\\n  /// @notice Address of the dummy implementation used to make the DiamondProxy contract interpretable by Etherscan\\n  function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0xf742b55592d129e02fb755d25f7a97ed976a14c4c744d6ac46726809e8f1e037\",\"license\":\"MIT\"},\"project/contracts/interfaces/IDiamondLoupe.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @notice IDiamondLoupe\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/interfaces/IDiamondLoupe.sol by mudgen\\ninterface IDiamondLoupe {\\n  /// @notice Gets all facet addresses and their four byte function selectors.\\n  /// @return facets_ Facet\\n  function facets() external view returns (Facet[] memory facets_);\\n\\n  /// @notice Gets all the function selectors supported by a specific facet.\\n  /// @param _facet The facet address.\\n  /// @return facetFunctionSelectors_\\n  function facetFunctionSelectors(address _facet) external view returns (bytes4[] memory facetFunctionSelectors_);\\n\\n  /// @notice Get all the facet addresses used by a diamond.\\n  /// @return facetAddresses_\\n  function facetAddresses() external view returns (address[] memory facetAddresses_);\\n\\n  /// @notice Gets the facet that supports the given selector.\\n  /// @dev If facet is not found return address(0).\\n  /// @param _functionSelector The function selector.\\n  /// @return facetAddress_ The facet address.\\n  function facetAddress(bytes4 _functionSelector) external view returns (address facetAddress_);\\n}\\n\",\"keccak256\":\"0xa5580958acabe2c44967e835e77a748eb0b8812f70cd071191201508c9388ca8\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  function getSwapRouter() external view returns (address);\\n\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x27a333b02ba124b5964a63bddeb301328197bddbe98538903cd41a8b40900d12\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IDiamondCut } from \\\"./IDiamondCut.sol\\\";\\nimport { IDiamondEtherscan } from \\\"./IDiamondEtherscan.sol\\\";\\nimport { IDiamondLoupe } from \\\"./IDiamondLoupe.sol\\\";\\nimport { IGetters } from \\\"./IGetters.sol\\\";\\nimport { IRedeemer } from \\\"./IRedeemer.sol\\\";\\nimport { IRewardHandler } from \\\"./IRewardHandler.sol\\\";\\nimport { ISettersGovernor, ISettersGuardian } from \\\"./ISetters.sol\\\";\\nimport { ISwapper } from \\\"./ISwapper.sol\\\";\\nimport { ISurplus } from \\\"./ISurplus.sol\\\";\\n\\n/// @title IParallelizer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuter` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuter.sol\\ninterface IParallelizer is\\n  IDiamondCut,\\n  IDiamondEtherscan,\\n  IDiamondLoupe,\\n  IGetters,\\n  IRedeemer,\\n  IRewardHandler,\\n  ISettersGovernor,\\n  ISettersGuardian,\\n  ISwapper,\\n  ISurplus\\n{ }\\n\",\"keccak256\":\"0x3d43efebf663185429a411300477c3a62bf5e025fb286cf812cd0b589fb8bd5a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRebalancer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRebalancer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IHarvester` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IHarvester.sol\\ninterface IRebalancer {\\n  function setYieldBearingAssetData(\\n    address yieldBearingAsset,\\n    address stablecoin,\\n    uint64 targetExposure,\\n    uint64 minExposureYieldAsset,\\n    uint64 maxExposureYieldAsset,\\n    uint64 overrideExposures,\\n    uint64 maxSlippage\\n  )\\n    external;\\n\\n  function updateLimitExposuresYieldAsset(address yieldBearingAsset) external;\\n\\n  function setMaxSlippage(address yieldBearingAsset, uint64 newMaxSlippage) external;\\n\\n  function harvest(address yieldBearingAsset, uint256 scale, bytes calldata extraData) external;\\n}\\n\",\"keccak256\":\"0x0a30a492e29ebe67db0f4cac7bfb142d04556a61282e71733d13c11daeba08b1\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was\\n  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since\\n  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`\\n  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity\\n  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x3362bd4532915b6e2b26b2fdc967a89ea66de5ea5f669d7a621ee69d75c02273\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a call to the configured swap router\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to the swap router\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xb3604f35c5bb44791020588e00774299a6a4adae17d62d1e53cd8be86da6b709\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n\\n  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain\\n  /// specific and must be set on every deployment before rewards can be sold\\n  function setSwapRouter(address swapRouter) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xe62d2880420afb053498b01f1def17d4c8e2c6c9b48cc5a71d013150a5ca8db4\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISurplus.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISurplus {\\n  /// @dev This function will swap the surplus of a collateral for the stable asset link to the protocol.\\n  /// @param collateral The collateral address to process the surplus of.\\n  /// @param maxCollateralAmount The maximum amount of collateral to process. If 0, processes the full surplus.\\n  /// @return collateralSurplus The surplus of the collateral actually processed.\\n  /// @return stableSurplus The surplus amount in stable calculated from the collateral surplus.\\n  /// @return issuedAmount The amount of newly issued stablecoins from the collateral swapped\\n  function processSurplus(\\n    address collateral,\\n    uint256 maxCollateralAmount\\n  )\\n    external\\n    returns (uint256 collateralSurplus, uint256 stableSurplus, uint256 issuedAmount);\\n\\n  /// @notice Releases the income to the payees\\n  /// @return payees The addresses of the payees\\n  /// @return amounts The amounts released to the payees\\n  function release() external returns (address[] memory payees, uint256[] memory amounts);\\n}\\n\",\"keccak256\":\"0x0129ea80a666d553ddd13c02f56a72cc96a6ac4e45578f0f523def2732ce450f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title ISwapper\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISwapper` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISwapper.sol\\ninterface ISwapper {\\n  /// @notice Swaps (that is to say mints or burns) an exact amount of `tokenIn` for an amount of `tokenOut`\\n  /// @param amountIn Amount of `tokenIn` to bring\\n  /// @param amountOutMin Minimum amount of `tokenOut` to get: if `amountOut` is inferior to this amount, the\\n  /// function will revert\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountOut Amount of `tokenOut` obtained through the swap\\n  function swapExactInput(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactInput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactInputWithPermit(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Swaps (that is to say mints or burns) an amount of `tokenIn` for an exact amount of `tokenOut`\\n  /// @param amountOut Amount of `tokenOut` to obtain from the swap\\n  /// @param amountInMax Maximum amount of `tokenIn` to bring in order to get `amountOut` of `tokenOut`\\n  /// @param tokenIn Token to bring for the swap\\n  /// @param tokenOut Token to get out of the swap\\n  /// @param to Address to which `tokenOut` must be sent\\n  /// @param deadline Timestamp before which the transaction must be executed\\n  /// @return amountIn Amount of `tokenIn` used to perform the swap\\n  function swapExactOutput(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactOutput`, but using Permit2 signatures for `tokenIn`\\n  /// @dev Can only be used to mint, hence `tokenOut` is not needed\\n  function swapExactOutputWithPermit(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata permitData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Same as `swapExactInput`, but using a single EIP-3009 authorization for `tokenIn`.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeSwapExactInputNonce(...)`,\\n  /// which binds the full swap intent. `authData.nonce` carries the caller-chosen `userSalt`; the\\n  /// facet recomputes the derived nonce from the call arguments before forwarding it to the\\n  /// token, so any tampering with `to`/slippage/deadline invalidates the signature.\\n  /// @param authData ABI-encoded `AuthorizationParams` with `nonce = userSalt`\\n  function swapExactInputWithAuthorization(\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata authData\\n  )\\n    external\\n    returns (uint256 amountOut);\\n\\n  /// @notice Same as `swapExactOutput`, but using a single EIP-3009 authorization for `tokenIn`.\\n  /// @dev The authorization must be signed for `amountInMax`; the excess is refunded to the\\n  /// authorizer. Derived-nonce scheme as in `swapExactInputWithAuthorization`, using\\n  /// `LibAuthorization.computeSwapExactOutputNonce(...)`.\\n  /// @param authData ABI-encoded `AuthorizationParams` with `nonce = userSalt`\\n  function swapExactOutputWithAuthorization(\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address tokenIn,\\n    address tokenOut,\\n    address to,\\n    uint256 deadline,\\n    bytes calldata authData\\n  )\\n    external\\n    returns (uint256 amountIn);\\n\\n  /// @notice Simulates what a call to `swapExactInput` with `amountIn` of `tokenIn` for `tokenOut` would give.\\n  /// If called right before and at the same block, the `amountOut` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactInput`\\n  function quoteIn(uint256 amountIn, address tokenIn, address tokenOut) external view returns (uint256 amountOut);\\n\\n  /// @notice Simulates what a call to `swapExactOutput` for `amountOut` of `tokenOut` with `tokenIn` would give.\\n  /// If called right before and at the same block, the `amountIn` outputted by this function is exactly the\\n  /// amount that will be obtained with `swapExactOutput`\\n  function quoteOut(uint256 amountOut, address tokenIn, address tokenOut) external view returns (uint256 amountIn);\\n}\\n\",\"keccak256\":\"0xbf7e08cff6dd51c222f86976d3526307098b80100c81978a55566043924cfc06\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IERC4626.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\n// OpenZeppelin Contracts (last updated v4.7.0) (interfaces/IERC4626.sol)\\n\\npragma solidity >=0.5.0;\\n\\n/// @notice ERC4626 interface\\n/// @author OpenZeppelin\\n/// @dev In this implementation, the interface only contains the functions that the IERC4626 interface adds on top of\\n/// the IERC20 interface\\ninterface IERC4626 {\\n  /**\\n   * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.\\n   *\\n   * - MUST be an ERC-20 token contract.\\n   * - MUST NOT revert.\\n   */\\n  function asset() external view returns (address assetTokenAddress);\\n\\n  /**\\n   * @dev Returns the total amount of the underlying asset that is \\u201cmanaged\\u201d by Vault.\\n   *\\n   * - SHOULD include any compounding that occurs from yield.\\n   * - MUST be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT revert.\\n   */\\n  function totalAssets() external view returns (uint256 totalManagedAssets);\\n\\n  /**\\n   * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToShares(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal\\n   * scenario where all the conditions are met.\\n   *\\n   * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.\\n   * - MUST NOT show any variations depending on the caller.\\n   * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: This calculation MAY NOT reflect the \\u201cper-user\\u201d price-per-share, and instead should reflect the\\n   * \\u201caverage-user\\u2019s\\u201d price-per-share, meaning what the average user should expect to see when exchanging to and\\n   * from.\\n   */\\n  function convertToAssets(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,\\n   * through a deposit call.\\n   *\\n   * - MUST return a limited value if receiver is subject to some deposit limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.\\n   * - MUST NOT revert.\\n   */\\n  function maxDeposit(address receiver) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit\\n   *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called\\n   *   in the same transaction.\\n   * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the\\n   *   deposit would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewDeposit(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   deposit execution, and are accounted for during deposit.\\n   * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function deposit(uint256 assets, address receiver) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.\\n   * - MUST return a limited value if receiver is subject to some mint limit.\\n   * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.\\n   * - MUST NOT revert.\\n   */\\n  function maxMint(address receiver) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given\\n   * current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call\\n   *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the\\n   *   same transaction.\\n   * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint\\n   *   would be accepted, regardless if the user has enough tokens approved, etc.\\n   * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by minting.\\n   */\\n  function previewMint(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.\\n   *\\n   * - MUST emit the Deposit event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint\\n   *   execution, and are accounted for during mint.\\n   * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not\\n   *   approving enough underlying tokens to the Vault contract, etc).\\n   *\\n   * NOTE: most implementations will require pre-approval of the Vault with the Vault\\u2019s underlying asset token.\\n   */\\n  function mint(uint256 shares, address receiver) external returns (uint256 assets);\\n\\n  /**\\n   * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the\\n   * Vault, through a withdraw call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxWithdraw(address owner) external view returns (uint256 maxAssets);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw\\n   *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if\\n   *   called\\n   *   in the same transaction.\\n   * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though\\n   *   the withdrawal would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by depositing.\\n   */\\n  function previewWithdraw(uint256 assets) external view returns (uint256 shares);\\n\\n  /**\\n   * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   withdraw execution, and are accounted for during withdraw.\\n   * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);\\n\\n  /**\\n   * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,\\n   * through a redeem call.\\n   *\\n   * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.\\n   * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.\\n   * - MUST NOT revert.\\n   */\\n  function maxRedeem(address owner) external view returns (uint256 maxShares);\\n\\n  /**\\n   * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,\\n   * given current on-chain conditions.\\n   *\\n   * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call\\n   *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the\\n   *   same transaction.\\n   * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the\\n   *   redemption would be accepted, regardless if the user has enough shares, etc.\\n   * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.\\n   * - MUST NOT revert.\\n   *\\n   * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in\\n   * share price or some other type of condition, meaning the depositor will lose assets by redeeming.\\n   */\\n  function previewRedeem(uint256 shares) external view returns (uint256 assets);\\n\\n  /**\\n   * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.\\n   *\\n   * - MUST emit the Withdraw event.\\n   * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the\\n   *   redeem execution, and are accounted for during redeem.\\n   * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner\\n   *   not having enough shares, etc).\\n   *\\n   * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.\\n   * Those methods should be performed separately.\\n   */\\n  function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);\\n}\\n\",\"keccak256\":\"0xd730d6a6b679201eec89dff3133de651da20b3e72e74f01b734078bfacf952ad\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/AccessManaged.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { IAccessManaged } from \\\"@openzeppelin/contracts/access/manager/IAccessManaged.sol\\\";\\nimport { Context } from \\\"@openzeppelin/contracts/utils/Context.sol\\\";\\n\\nimport \\\"../utils/Errors.sol\\\";\\n\\n/// @title AccessControl\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Fork of OpenZeppelin's `AccessManaged` contract\\n/// updated to make _checkCanCall to return bool\\n/// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/access/manager/AccessManaged.sol\\ncontract AccessManaged is Context, IAccessManaged {\\n  address private _authority;\\n\\n  bool private _consumingSchedule;\\n\\n  /**\\n   * @dev Initializes the contract connected to an initial authority.\\n   */\\n  constructor(address initialAuthority) {\\n    _setAuthority(initialAuthority);\\n  }\\n\\n  /**\\n   * @dev Restricts access to a function as defined by the connected Authority for this contract and the\\n   * caller and selector of the function that entered the contract.\\n   *\\n   * [IMPORTANT]\\n   * ====\\n   * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`\\n   * functions that are used as external entry points and are not called internally. Unless you know what you're\\n   * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security\\n   * implications! This is because the permissions are determined by the function that entered the contract, i.e. the\\n   * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.\\n   * ====\\n   *\\n   * [WARNING]\\n   * ====\\n   * Avoid adding this modifier to the\\n   * https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]\\n   * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These\\n   * functions are the only execution paths where a function selector cannot be unambiguously determined from the\\n   * calldata\\n   * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()`\\n   * function\\n   * if no calldata is provided. (See {_checkCanCall}).\\n   *\\n   * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.\\n   * ====\\n   */\\n  modifier restricted() {\\n    address caller = _msgSender();\\n    require(_checkCanCall(caller, _msgData()), AccessManagedUnauthorized(caller));\\n    _;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function authority() public view virtual returns (address) {\\n    return _authority;\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function setAuthority(address newAuthority) public virtual {\\n    address caller = _msgSender();\\n    if (caller != authority()) {\\n      revert AccessManagedUnauthorized(caller);\\n    }\\n    if (newAuthority.code.length == 0) {\\n      revert AccessManagedInvalidAuthority(newAuthority);\\n    }\\n    _setAuthority(newAuthority);\\n  }\\n\\n  /// @inheritdoc IAccessManaged\\n  function isConsumingScheduledOp() public view returns (bytes4) {\\n    return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /**\\n   * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the\\n   * permissions set by the current authority.\\n   */\\n  function _setAuthority(address newAuthority) internal virtual {\\n    _authority = newAuthority;\\n    emit AuthorityUpdated(newAuthority);\\n  }\\n\\n  function _checkCanCall(address caller, bytes calldata data) internal virtual returns (bool) {\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(authority(), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        _consumingSchedule = true;\\n        IAccessManager(authority()).consumeScheduledOp(caller, data);\\n        _consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n}\\n\",\"keccak256\":\"0x40dfee0e736695b3005df6c150a2d794ac06f3f4b91745e2959623e770044798\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"},\"project/libs/helpers/RouterSwapper.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { SafeERC20, IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\n/// @title Swapper\\n/// @author Angle Labs, Inc.\\n/// @dev Abstract contract for swapping tokens using a router/aggregator\\n/// @dev This contract is an authorized fork of Angle's `RouterSwapper` contract\\n/// https://github.com/AngleProtocol/utils/blob/main/src/RouterSwapper.sol\\nabstract contract RouterSwapper {\\n  using SafeERC20 for IERC20;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               ERRORS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  error SwapError();\\n  error ZeroAddress();\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                EVENTS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   *  @notice Event emitted when the swap router is updated\\n   */\\n  event SwapRouterUpdated(address newSwapRouter);\\n  /**\\n   *  @notice Event emitted when the token proxy is updated\\n   */\\n  event TokenTransferAddressUpdated(address newTokenTransferAddress);\\n\\n  /*//////////////////////////////////////////////////////////////\\n                                MODIFIERS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  modifier noZeroAddress(address targetAddress) {\\n    if (targetAddress == address(0)) {\\n      revert ZeroAddress();\\n    }\\n    _;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                            MUTABLE VARIABLES\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice address of the router/aggregator\\n   */\\n  address public swapRouter;\\n  /**\\n   * @notice address to approve to transfer tokens to\\n   */\\n  address public tokenTransferAddress;\\n\\n  /*//////////////////////////////////////////////////////////////\\n                               CONSTRUCTOR\\n    //////////////////////////////////////////////////////////////*/\\n\\n  constructor(address initialSwapRouter, address initialTokenTransferAddress) {\\n    swapRouter = initialSwapRouter;\\n    tokenTransferAddress = initialTokenTransferAddress;\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             ADMIN FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Set the router/aggregator address\\n   * @param newSwapRouter address of the new router/aggregator\\n   */\\n  function setSwapRouter(address newSwapRouter) public virtual noZeroAddress(newSwapRouter) {\\n    swapRouter = newSwapRouter;\\n\\n    emit SwapRouterUpdated(newSwapRouter);\\n  }\\n\\n  /**\\n   * @notice Set the token transfer address\\n   * @param newTokenTransferAddress address of the new token transfer address\\n   */\\n  function setTokenTransferAddress(address newTokenTransferAddress)\\n    public\\n    virtual\\n    noZeroAddress(newTokenTransferAddress)\\n  {\\n    tokenTransferAddress = newTokenTransferAddress;\\n\\n    emit TokenTransferAddressUpdated(newTokenTransferAddress);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////\\n                             SWAP FUNCTIONS\\n    //////////////////////////////////////////////////////////////*/\\n\\n  /**\\n   * @notice Approve the router/aggregator to spend the token if needed\\n   * @param token address of the token to approve\\n   * @param spender address of the router/aggregator\\n   * @param amount amount to approve\\n   */\\n  function _approveTokenIfNeeded(address token, address spender, uint256 amount) internal {\\n    uint256 allowance = IERC20(token).allowance(address(this), spender);\\n    if (allowance < amount) {\\n      IERC20(token).safeIncreaseAllowance(spender, amount - allowance);\\n    }\\n  }\\n\\n  /**\\n   * @notice Perform the swap using the router/aggregator\\n   * @param callData bytes to call the router/aggregator\\n   */\\n  function _performRouterSwap(bytes memory callData) internal {\\n    (bool success, bytes memory retData) = swapRouter.call(callData);\\n\\n    if (!success) {\\n      if (retData.length != 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          revert(add(32, retData), mload(retData))\\n        }\\n      }\\n      revert SwapError();\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swapCalldata(address[] calldata tokens, bytes[] calldata callDatas, uint256[] calldata amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n\\n  /**\\n   * @notice Swap tokens using the router/aggregator\\n   * @param tokens array of tokens to swap\\n   * @param callDatas array of bytes to call the router/aggregator\\n   * @param amounts array of amounts to swap\\n   */\\n  function _swap(address[] memory tokens, bytes[] memory callDatas, uint256[] memory amounts) internal {\\n    uint256 length = tokens.length;\\n    for (uint256 i; i < length; ++i) {\\n      _approveTokenIfNeeded(tokens[i], tokenTransferAddress, amounts[i]);\\n      _performRouterSwap(callDatas[i]);\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x8c5a6b026a95816806814ef681b6b225ea4c405a39a4eab0111921853202829c\",\"license\":\"GPL-3.0\"}},\"version\":1}",
+  "storageLayout": {
+    "storage": [
+      {
+        "astId": 29857,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "_authority",
+        "offset": 0,
+        "slot": "0",
+        "type": "t_address"
+      },
+      {
+        "astId": 29859,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "_consumingSchedule",
+        "offset": 20,
+        "slot": "0",
+        "type": "t_bool"
+      },
+      {
+        "astId": 10262,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "yieldBearingData",
+        "offset": 0,
+        "slot": "1",
+        "type": "t_mapping(t_address,t_struct(YieldBearingParams)10202_storage)"
+      },
+      {
+        "astId": 10267,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "isTrusted",
+        "offset": 0,
+        "slot": "2",
+        "type": "t_mapping(t_address,t_bool)"
+      },
+      {
+        "astId": 30616,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "swapRouter",
+        "offset": 0,
+        "slot": "3",
+        "type": "t_address"
+      },
+      {
+        "astId": 30619,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "tokenTransferAddress",
+        "offset": 0,
+        "slot": "4",
+        "type": "t_address"
+      },
+      {
+        "astId": 11058,
+        "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+        "label": "budget",
+        "offset": 0,
+        "slot": "5",
+        "type": "t_mapping(t_address,t_uint256)"
+      }
+    ],
+    "types": {
+      "t_address": {
+        "encoding": "inplace",
+        "label": "address",
+        "numberOfBytes": "20"
+      },
+      "t_bool": {
+        "encoding": "inplace",
+        "label": "bool",
+        "numberOfBytes": "1"
+      },
+      "t_mapping(t_address,t_bool)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => bool)",
+        "numberOfBytes": "32",
+        "value": "t_bool"
+      },
+      "t_mapping(t_address,t_struct(YieldBearingParams)10202_storage)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => struct YieldBearingParams)",
+        "numberOfBytes": "32",
+        "value": "t_struct(YieldBearingParams)10202_storage"
+      },
+      "t_mapping(t_address,t_uint256)": {
+        "encoding": "mapping",
+        "key": "t_address",
+        "label": "mapping(address => uint256)",
+        "numberOfBytes": "32",
+        "value": "t_uint256"
+      },
+      "t_struct(YieldBearingParams)10202_storage": {
+        "encoding": "inplace",
+        "label": "struct YieldBearingParams",
+        "members": [
+          {
+            "astId": 10191,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "asset",
+            "offset": 0,
+            "slot": "0",
+            "type": "t_address"
+          },
+          {
+            "astId": 10193,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "targetExposure",
+            "offset": 20,
+            "slot": "0",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10195,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "maxExposure",
+            "offset": 0,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10197,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "minExposure",
+            "offset": 8,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10199,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "overrideExposures",
+            "offset": 16,
+            "slot": "1",
+            "type": "t_uint64"
+          },
+          {
+            "astId": 10201,
+            "contract": "project/contracts/helpers/GenericRebalancer.sol:GenericRebalancer",
+            "label": "maxSlippage",
+            "offset": 24,
+            "slot": "1",
+            "type": "t_uint64"
+          }
+        ],
+        "numberOfBytes": "64"
+      },
+      "t_uint256": {
+        "encoding": "inplace",
+        "label": "uint256",
+        "numberOfBytes": "32"
+      },
+      "t_uint64": {
+        "encoding": "inplace",
+        "label": "uint64",
+        "numberOfBytes": "8"
+      }
+    }
+  },
+  "userdoc": {
+    "events": {
+      "SwapRouterUpdated(address)": {
+        "notice": "Event emitted when the swap router is updated"
+      },
+      "TokenTransferAddressUpdated(address)": {
+        "notice": "Event emitted when the token proxy is updated"
+      }
+    },
+    "kind": "user",
+    "methods": {
+      "addBudget(uint256,address)": {
+        "notice": "Add budget to be spent by the receiver during the flashloan"
+      },
+      "budget(address)": {
+        "notice": "Budget of tokenP available for each users"
+      },
+      "computeRebalanceAmount(address)": {
+        "notice": "Compute the amount needed to rebalance the Parallelizer"
+      },
+      "flashloan()": {
+        "notice": "Parallel stablecoin flashloan contract"
+      },
+      "harvest(address,uint256,bytes)": {
+        "notice": "Invests or divests from the yield asset associated to `yieldBearingAsset` based on the current exposure  to this yieldBearingAsset"
+      },
+      "isTrusted(address)": {
+        "notice": "trusted addresses that can update target exposure and do others non critical operations"
+      },
+      "parallelizer()": {
+        "notice": "Reference to the `parallelizer` implementation this contract aims at rebalancing"
+      },
+      "recoverERC20(address,uint256,address)": {
+        "notice": "Recover ERC20 tokens"
+      },
+      "removeBudget(uint256,address)": {
+        "notice": "Remove budget from the owner and send it to the receiver"
+      },
+      "resetAllowance(address,address)": {
+        "notice": "Set an allowance this contract granted back to zero"
+      },
+      "setMaxSlippage(address,uint64)": {
+        "notice": "Set the max allowed slippage"
+      },
+      "setSwapRouter(address)": {
+        "notice": "Set the swap router"
+      },
+      "setTargetExposure(address,uint64)": {
+        "notice": "Set the target exposure of a yield bearing asset"
+      },
+      "setTokenTransferAddress(address)": {
+        "notice": "Set the token transfer address"
+      },
+      "setYieldBearingAssetData(address,address,uint64,uint64,uint64,uint64,uint64)": {
+        "notice": "Set the yieldBearingAsset data"
+      },
+      "swapRouter()": {
+        "notice": "address of the router/aggregator"
+      },
+      "toggleTrusted(address)": {
+        "notice": "Toggle the trusted status of an address"
+      },
+      "tokenP()": {
+        "notice": "TokenP handled by the `parallelizer` of interest"
+      },
+      "tokenTransferAddress()": {
+        "notice": "address to approve to transfer tokens to"
+      },
+      "updateLimitExposuresYieldAsset(address)": {
+        "notice": "Set the limit exposures to the asset linked to the yield bearing asset"
+      },
+      "yieldBearingData(address)": {
+        "notice": "Data associated to a yield bearing asset"
+      }
+    },
+    "version": 1
+  },
+  "argsData": "0x000000000000000000000000744489ee3d540777a66f2cf297479745e0852f7a000000000000000000000000744489ee3d540777a66f2cf297479745e0852f7a000000000000000000000000be65f0f410a72bec163dc65d46c83699e957d5880000000000000000000000001250304f66404cd153fa39388ddcdaec7e0f1707000000000000000000000000028c3e3a0984c441c5205cfd0c39a6cf244ee69600000000000000000000000015452454a9735d68df430879b2941316a09295b1",
+  "transaction": {
+    "nonce": "0xdc",
+    "hash": "0x21ab1bb91673e694594eb8d8daa2270401ffa3abd090c9c7a9170981c7b6d27e",
+    "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
+  },
+  "receipt": {
+    "blockHash": "0x683b8792ef031ed72bb7cad4fe3d544ad3170c47f5b70b4f98ab39bb9b19bb7d",
+    "blockNumber": "0x2e5a0e4",
+    "transactionIndex": "0x4"
+  }
+}
\ No newline at end of file
diff --git a/deployments/hyperevm/Getters.json b/deployments/hyperevm/Getters.json
index eeca865..916c23d 100644
--- a/deployments/hyperevm/Getters.json
+++ b/deployments/hyperevm/Getters.json
@@ -1,5 +1,5 @@
 {
-  "address": "0xf1b0c99fa5fc90410cca1219cabb91fc7e752292",
+  "address": "0xa6fdbd9953837157aab1b43280f27321da621abf",
   "abi": [
     {
       "inputs": [],
@@ -549,6 +549,19 @@
       "stateMutability": "view",
       "type": "function"
     },
+    {
+      "inputs": [],
+      "name": "getSwapRouter",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
     {
       "inputs": [],
       "name": "getTotalIssued",
@@ -752,8 +765,8 @@
   ],
   "contractName": "Getters",
   "sourceName": "contracts/parallelizer/facets/Getters.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -804,7 +817,7 @@
       "getSlippageTolerance(address)": {
         "details": "Maximum slippage tolerance is 1e9 (100%)"
       },
-      "getSurplusBufferRatio()": {
+      "getSwapRouter()": {
         "details": "Expressed in base 1e9, and always >= 1e9"
       },
       "isConsumingScheduledOp()": {
@@ -823,9 +836,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "3346200",
-        "executionCost": "3721",
-        "totalCost": "3349921"
+        "codeDepositCost": "3358000",
+        "executionCost": "3737",
+        "totalCost": "3361737"
       },
       "external": {
         "accessManager()": "2418",
@@ -847,7 +860,8 @@
         "getShares(address)": "2561",
         "getSlippageTolerance(address)": "2564",
         "getStablecoinCap(address)": "infinite",
-        "getSurplusBufferRatio()": "2356",
+        "getSurplusBufferRatio()": "2334",
+        "getSwapRouter()": "2420",
         "getTotalIssued()": "infinite",
         "getTotalShares()": "2369",
         "isConsumingScheduledOp()": "infinite",
@@ -862,7 +876,7 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SurplusBufferRatioNotSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroSurplusAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"accessManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralBurnFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralDecimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isManaged\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isMintLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isBurnLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"onlyWhitelisted\",\"type\":\"uint8\"},{\"internalType\":\"uint216\",\"name\":\"normalizedStables\",\"type\":\"uint216\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinCap\",\"type\":\"uint256\"}],\"internalType\":\"struct Collateral\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralList\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralMintFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"collatRatio\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralSurplus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"collateralSurplus\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableSurplus\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralWhitelistData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getIssuedByCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stablecoinsFromCollateral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastReleasedAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getManagerData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracle\",\"outputs\":[{\"internalType\":\"enum OracleReadType\",\"name\":\"oracleType\",\"type\":\"uint8\"},{\"internalType\":\"enum OracleReadType\",\"name\":\"targetType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"oracleData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"targetData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hyperparameters\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracleValues\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"mint\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"burn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ratio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minRatio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"redemption\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPayees\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRedemptionFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xRedemptionCurve\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yRedemptionCurve\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"getShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getSlippageTolerance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getStablecoinCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSurplusBufferRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"enum ActionType\",\"name\":\"action\",\"type\":\"uint8\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrustedSeller\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"isValidSelector\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"isWhitelistedCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enum WhitelistType\",\"name\":\"whitelistType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForType\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"There may be duplicates in the info provided by the getters defined hereThis contract is an authorized fork of Angle's `Getters` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}]},\"kind\":\"dev\",\"methods\":{\"getCollateralRatio()\":{\"details\":\"This function may revert and overflow if the collateral ratio is too big due to a too small amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function become economically impossible\"},\"getCollateralSurplus(address)\":{\"params\":{\"collateral\":\"The collateral address to compute the surplus of.\"},\"returns\":{\"collateralSurplus\":\"The collateral surplus amount.\",\"stableSurplus\":\"The surplus in stable amount.\"}},\"getOracle(address)\":{\"returns\":{\"oracleData\":\"Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\",\"oracleType\":\"Type of oracle (Chainlink, external smart contract, ...)\",\"targetData\":\"Extra data needed to read the target price of the asset\",\"targetType\":\"Type passed to read the value of the target price\"}},\"getOracleValues(address)\":{\"details\":\"This function is not optimized for gas consumption as for instance the `burn` value for collateral is computed twice: once in `readBurn` and once in `getBurnOracle`\",\"returns\":{\"burn\":\"Oracle value that will be used for `collateral` for a burn transaction. This value is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\",\"minRatio\":\"Minimum ratio across all collateral assets between a collateral burn price and its target price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn transactions.\",\"mint\":\"Oracle value to be used for a mint transaction with `collateral`\",\"ratio\":\"Ratio, in base `10**18` between the oracle value of the `collateral` and its target price. This value is 10**18 if the oracle is greater than the collateral price\",\"redemption\":\"Oracle value that would be used to price `collateral` when computing the collateral ratio during a redemption\"}},\"getSlippageTolerance(address)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)\"},\"getSurplusBufferRatio()\":{\"details\":\"Expressed in base 1e9, and always >= 1e9\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"isWhitelistedForCollateral(address,address)\":{\"details\":\"This function is non view as it may consult external non view functions from whitelist providers\"},\"isWhitelistedForType(uint8,address)\":{\"details\":\"Note that ultimately whitelisting may depend as well on external providers\"}},\"title\":\"Getters\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"accessManager()\":{\"notice\":\"Returns the address of the `accessManager` contract\"},\"getCollateralBurnFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn for `collateral`\"},\"getCollateralDecimals(address)\":{\"notice\":\"Returns the decimals of a given `collateral`\"},\"getCollateralInfo(address)\":{\"notice\":\"Returns all the info in storage associated to a `collateral`\"},\"getCollateralList()\":{\"notice\":\"Returns the list of collateral assets supported by the system\"},\"getCollateralMintFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint with `collateral`\"},\"getCollateralRatio()\":{\"notice\":\"Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount of stablecoins issued\"},\"getCollateralSurplus(address)\":{\"notice\":\"Computes the surplus of a collateral.\"},\"getCollateralWhitelistData(address)\":{\"notice\":\"Gets the data needed to deal with whitelists for `collateral`\"},\"getIssuedByCollateral(address)\":{\"notice\":\"Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued through Parallelizer\"},\"getLastReleasedAt()\":{\"notice\":\"Returns the last time the income was released to the payees\"},\"getManagerData(address)\":{\"notice\":\"Returns if a collateral is \\\"managed\\\" and the associated manager configuration\"},\"getOracle(address)\":{\"notice\":\"Returns the data used to compute oracle values for `collateral`\"},\"getOracleValues(address)\":{\"notice\":\"Returns the oracle values associated to `collateral`\"},\"getPayees()\":{\"notice\":\"Returns the payees and their shares\"},\"getRedemptionFees()\":{\"notice\":\"Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral ratio when users come to redeem\"},\"getShares(address)\":{\"notice\":\"Returns the shares of a payee\"},\"getSlippageTolerance(address)\":{\"notice\":\"Returns the slippage tolerance for a `collateral` for the surplus\"},\"getStablecoinCap(address)\":{\"notice\":\"Returns the stablecoin cap for `collateral`\"},\"getSurplusBufferRatio()\":{\"notice\":\"Returns the minimum collateral ratio that must hold after surplus processing\"},\"getTotalIssued()\":{\"notice\":\"Returns the total amount of stablecoins issued through Parallelizer\"},\"getTotalShares()\":{\"notice\":\"Returns the total shares of the payees\"},\"isPaused(address,uint8)\":{\"notice\":\"Returns if the associated functionality is paused or not\"},\"isTrusted(address)\":{\"notice\":\"Returns if `sender` is trusted to update normalizers\"},\"isTrustedSeller(address)\":{\"notice\":\"Returns if `sender` is trusted to update sell rewards\"},\"isValidSelector(bytes4)\":{\"notice\":\"Checks whether a given `selector` is actually a valid selector corresponding to a function in one of the facets of the proxy\"},\"isWhitelistedCollateral(address)\":{\"notice\":\"Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForCollateral(address,address)\":{\"notice\":\"Checks whether `sender` can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForType(uint8,address)\":{\"notice\":\"Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\"},\"tokenP()\":{\"notice\":\"Stablecoin minted by parallelizer\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Getters.sol\":\"Getters\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x04f12ddeb53bb3bba9aaf9a93c62a84076cca496642d4d87556b15120b60e07b\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Getters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IGetters } from \\\"contracts/interfaces/IGetters.sol\\\";\\n\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibSurplus } from \\\"../libraries/LibSurplus.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Getters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev There may be duplicates in the info provided by the getters defined here\\n/// @dev This contract is an authorized fork of Angle's `Getters` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\\ncontract Getters is IGetters {\\n  /// @inheritdoc IGetters\\n  function isValidSelector(bytes4 selector) external view returns (bool) {\\n    return s.diamondStorage().selectorInfo[selector].facetAddress != address(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function tokenP() external view returns (ITokenP) {\\n    return s.transmuterStorage().tokenP;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralList() external view returns (address[] memory) {\\n    return s.transmuterStorage().collateralList;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory) {\\n    return s.transmuterStorage().collaterals[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralDecimals(address collateral) external view returns (uint8) {\\n    return s.transmuterStorage().collaterals[collateral].decimals;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralMintFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeMint, int64[] memory yFeeMint)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeMint, collatInfo.yFeeMint);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralBurnFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeBurn, int64[] memory yFeeBurn)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeBurn, collatInfo.yFeeBurn);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getRedemptionFees()\\n    external\\n    view\\n    returns (uint64[] memory xRedemptionCurve, int64[] memory yRedemptionCurve)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (ts.xRedemptionCurve, ts.yRedemptionCurve);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function may revert and overflow if the collateral ratio is too big due to a too small\\n  /// amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non\\n  /// negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function\\n  /// become economically impossible\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n\\n    (collatRatio, stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    return (\\n      (uint256(ts.collaterals[collateral].normalizedStables) * _normalizer) / BASE_27,\\n      (uint256(ts.normalizedStables) * _normalizer) / BASE_27\\n    );\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalIssued() external view returns (uint256) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (uint256(ts.normalizedStables) * uint256(ts.normalizer)) / BASE_27;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getManagerData(address collateral) external view returns (bool, IERC20[] memory, bytes memory) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      return (true, collatInfo.managerData.subCollaterals, collatInfo.managerData.config);\\n    }\\n    return (false, new IERC20[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is not optimized for gas consumption as for instance the `burn` value for collateral\\n  /// is computed twice: once in `readBurn` and once in `getBurnOracle`\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption)\\n  {\\n    bytes memory oracleConfig = s.transmuterStorage().collaterals[collateral].oracleConfig;\\n    (burn, ratio) = LibOracle.readBurn(oracleConfig);\\n    (minRatio,) = LibOracle.getBurnOracle(collateral, oracleConfig);\\n    return (LibOracle.readMint(oracleConfig), burn, ratio, minRatio, LibOracle.readRedemption(oracleConfig));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    )\\n  {\\n    return LibOracle.getOracle(collateral);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isPaused(address collateral, ActionType action) external view returns (bool) {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      if (action == ActionType.Mint) {\\n        return collatInfo.isMintLive == 0;\\n      } else {\\n        return collatInfo.isBurnLive == 0;\\n      }\\n    } else {\\n      return s.transmuterStorage().isRedemptionLive == 0;\\n    }\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrusted(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrustedSeller(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isSellerTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool) {\\n    return s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is non view as it may consult external non view functions from whitelist providers\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.onlyWhitelisted == 0 || LibWhitelist.checkWhitelist(collatInfo.whitelistData, sender));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedCollateral(address collateral) external view returns (bool) {\\n    return s.transmuterStorage().collaterals[collateral].onlyWhitelisted == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory) {\\n    return s.transmuterStorage().collaterals[collateral].whitelistData;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getStablecoinCap(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().collaterals[collateral].stablecoinCap;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function accessManager() external view returns (address) {\\n    return address(s.diamondStorage().accessManager);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isConsumingScheduledOp() external view returns (bytes4) {\\n    return s.transmuterStorage().consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getPayees() external view returns (address[] memory, uint256[] memory) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory payees = new address[](ts.payees.length);\\n    uint256[] memory shares = new uint256[](ts.payees.length);\\n    for (uint256 i = 0; i < ts.payees.length; i++) {\\n      payees[i] = ts.payees[i];\\n      shares[i] = ts.shares[ts.payees[i]];\\n    }\\n    return (payees, shares);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalShares() external view returns (uint256) {\\n    return s.transmuterStorage().totalShares;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getShares(address payee) external view returns (uint256) {\\n    return s.transmuterStorage().shares[payee];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSlippageTolerance(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().slippageTolerance[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSurplusBufferRatio() external view returns (uint64) {\\n    return s.transmuterStorage().surplusBufferRatio;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getLastReleasedAt() external view returns (uint256) {\\n    return s.transmuterStorage().lastReleasedAt;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    return LibSurplus._computeCollateralSurplus(collateral);\\n  }\\n}\\n\",\"keccak256\":\"0xd53f1dc85e3e3b30205017bf00b54c9b511963034d382ecc647e65ad854b314e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"SurplusBufferRatioNotSet\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroSurplusAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"accessManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralBurnFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralDecimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralInfo\",\"outputs\":[{\"components\":[{\"internalType\":\"uint8\",\"name\":\"isManaged\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isMintLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"isBurnLive\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"},{\"internalType\":\"uint8\",\"name\":\"onlyWhitelisted\",\"type\":\"uint8\"},{\"internalType\":\"uint216\",\"name\":\"normalizedStables\",\"type\":\"uint216\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"},{\"internalType\":\"uint64[]\",\"name\":\"xFeeBurn\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeBurn\",\"type\":\"int64[]\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinCap\",\"type\":\"uint256\"}],\"internalType\":\"struct Collateral\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralList\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralMintFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xFeeMint\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yFeeMint\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCollateralRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"collatRatio\",\"type\":\"uint64\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralSurplus\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"collateralSurplus\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stableSurplus\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getCollateralWhitelistData\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getIssuedByCollateral\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"stablecoinsFromCollateral\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"stablecoinsIssued\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getLastReleasedAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getManagerData\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"},{\"internalType\":\"contract IERC20[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracle\",\"outputs\":[{\"internalType\":\"enum OracleReadType\",\"name\":\"oracleType\",\"type\":\"uint8\"},{\"internalType\":\"enum OracleReadType\",\"name\":\"targetType\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"oracleData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"targetData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"hyperparameters\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getOracleValues\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"mint\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"burn\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"ratio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minRatio\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"redemption\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getPayees\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getRedemptionFees\",\"outputs\":[{\"internalType\":\"uint64[]\",\"name\":\"xRedemptionCurve\",\"type\":\"uint64[]\"},{\"internalType\":\"int64[]\",\"name\":\"yRedemptionCurve\",\"type\":\"int64[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"}],\"name\":\"getShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getSlippageTolerance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"getStablecoinCap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSurplusBufferRatio\",\"outputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getSwapRouter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalIssued\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getTotalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"isConsumingScheduledOp\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"enum ActionType\",\"name\":\"action\",\"type\":\"uint8\"}],\"name\":\"isPaused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrusted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isTrustedSeller\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"selector\",\"type\":\"bytes4\"}],\"name\":\"isValidSelector\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"isWhitelistedCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForCollateral\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"enum WhitelistType\",\"name\":\"whitelistType\",\"type\":\"uint8\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"isWhitelistedForType\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenP\",\"outputs\":[{\"internalType\":\"contract ITokenP\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"There may be duplicates in the info provided by the getters defined hereThis contract is an authorized fork of Angle's `Getters` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}]},\"kind\":\"dev\",\"methods\":{\"getCollateralRatio()\":{\"details\":\"This function may revert and overflow if the collateral ratio is too big due to a too small amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function become economically impossible\"},\"getCollateralSurplus(address)\":{\"params\":{\"collateral\":\"The collateral address to compute the surplus of.\"},\"returns\":{\"collateralSurplus\":\"The collateral surplus amount.\",\"stableSurplus\":\"The surplus in stable amount.\"}},\"getOracle(address)\":{\"returns\":{\"oracleData\":\"Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\",\"oracleType\":\"Type of oracle (Chainlink, external smart contract, ...)\",\"targetData\":\"Extra data needed to read the target price of the asset\",\"targetType\":\"Type passed to read the value of the target price\"}},\"getOracleValues(address)\":{\"details\":\"This function is not optimized for gas consumption as for instance the `burn` value for collateral is computed twice: once in `readBurn` and once in `getBurnOracle`\",\"returns\":{\"burn\":\"Oracle value that will be used for `collateral` for a burn transaction. This value is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\",\"minRatio\":\"Minimum ratio across all collateral assets between a collateral burn price and its target price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn transactions.\",\"mint\":\"Oracle value to be used for a mint transaction with `collateral`\",\"ratio\":\"Ratio, in base `10**18` between the oracle value of the `collateral` and its target price. This value is 10**18 if the oracle is greater than the collateral price\",\"redemption\":\"Oracle value that would be used to price `collateral` when computing the collateral ratio during a redemption\"}},\"getSlippageTolerance(address)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)\"},\"getSwapRouter()\":{\"details\":\"Expressed in base 1e9, and always >= 1e9\"},\"isConsumingScheduledOp()\":{\"details\":\"Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs attacker controlled calls.\"},\"isWhitelistedForCollateral(address,address)\":{\"details\":\"This function is non view as it may consult external non view functions from whitelist providers\"},\"isWhitelistedForType(uint8,address)\":{\"details\":\"Note that ultimately whitelisting may depend as well on external providers\"}},\"title\":\"Getters\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"accessManager()\":{\"notice\":\"Returns the address of the `accessManager` contract\"},\"getCollateralBurnFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn for `collateral`\"},\"getCollateralDecimals(address)\":{\"notice\":\"Returns the decimals of a given `collateral`\"},\"getCollateralInfo(address)\":{\"notice\":\"Returns all the info in storage associated to a `collateral`\"},\"getCollateralList()\":{\"notice\":\"Returns the list of collateral assets supported by the system\"},\"getCollateralMintFees(address)\":{\"notice\":\"Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint with `collateral`\"},\"getCollateralRatio()\":{\"notice\":\"Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount of stablecoins issued\"},\"getCollateralSurplus(address)\":{\"notice\":\"Computes the surplus of a collateral.\"},\"getCollateralWhitelistData(address)\":{\"notice\":\"Gets the data needed to deal with whitelists for `collateral`\"},\"getIssuedByCollateral(address)\":{\"notice\":\"Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued through Parallelizer\"},\"getLastReleasedAt()\":{\"notice\":\"Returns the last time the income was released to the payees\"},\"getManagerData(address)\":{\"notice\":\"Returns if a collateral is \\\"managed\\\" and the associated manager configuration\"},\"getOracle(address)\":{\"notice\":\"Returns the data used to compute oracle values for `collateral`\"},\"getOracleValues(address)\":{\"notice\":\"Returns the oracle values associated to `collateral`\"},\"getPayees()\":{\"notice\":\"Returns the payees and their shares\"},\"getRedemptionFees()\":{\"notice\":\"Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral ratio when users come to redeem\"},\"getShares(address)\":{\"notice\":\"Returns the shares of a payee\"},\"getSlippageTolerance(address)\":{\"notice\":\"Returns the slippage tolerance for a `collateral` for the surplus\"},\"getStablecoinCap(address)\":{\"notice\":\"Returns the stablecoin cap for `collateral`\"},\"getSwapRouter()\":{\"notice\":\"Returns the minimum collateral ratio that must hold after surplus processingReturns the aggregator or DEX the `RewardHandler` forwards its swap payload to\"},\"getTotalIssued()\":{\"notice\":\"Returns the total amount of stablecoins issued through Parallelizer\"},\"getTotalShares()\":{\"notice\":\"Returns the total shares of the payees\"},\"isPaused(address,uint8)\":{\"notice\":\"Returns if the associated functionality is paused or not\"},\"isTrusted(address)\":{\"notice\":\"Returns if `sender` is trusted to update normalizers\"},\"isTrustedSeller(address)\":{\"notice\":\"Returns if `sender` is trusted to update sell rewards\"},\"isValidSelector(bytes4)\":{\"notice\":\"Checks whether a given `selector` is actually a valid selector corresponding to a function in one of the facets of the proxy\"},\"isWhitelistedCollateral(address)\":{\"notice\":\"Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForCollateral(address,address)\":{\"notice\":\"Checks whether `sender` can deal with `collateral` during burns and redemptions\"},\"isWhitelistedForType(uint8,address)\":{\"notice\":\"Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\"},\"tokenP()\":{\"notice\":\"Stablecoin minted by parallelizer\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Getters.sol\":\"Getters\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IGetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title IGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IGetters` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IGetters.sol\\ninterface IGetters {\\n  /// @notice Checks whether a given `selector` is actually a valid selector corresponding to a function in one of\\n  /// the\\n  /// facets of the proxy\\n  function isValidSelector(bytes4 selector) external view returns (bool);\\n\\n  /// @notice Stablecoin minted by parallelizer\\n  function tokenP() external view returns (ITokenP);\\n\\n  /// @notice Returns the list of collateral assets supported by the system\\n  function getCollateralList() external view returns (address[] memory);\\n\\n  /// @notice Returns all the info in storage associated to a `collateral`\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory);\\n\\n  /// @notice Returns the decimals of a given `collateral`\\n  function getCollateralDecimals(address collateral) external view returns (uint8);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to mint\\n  /// with `collateral`\\n  function getCollateralMintFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays from which fees are computed when coming to burn\\n  /// for `collateral`\\n  function getCollateralBurnFees(address collateral) external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the `xFee` and `yFee` arrays used to compute the penalty factor depending on the collateral\\n  /// ratio when users come to redeem\\n  function getRedemptionFees() external view returns (uint64[] memory, int64[] memory);\\n\\n  /// @notice Returns the collateral ratio of Parallelizer in base `10**9` and a rounded version of the total amount\\n  /// of stablecoins issued\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the total amount of stablecoins issued through Parallelizer\\n  function getTotalIssued() external view returns (uint256 stablecoinsIssued);\\n\\n  /// @notice Returns the amount of stablecoins issued from `collateral` and the total amount of stablecoins issued\\n  /// through Parallelizer\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued);\\n\\n  /// @notice Returns if a collateral is \\\"managed\\\" and the associated manager configuration\\n  function getManagerData(address collateral)\\n    external\\n    view\\n    returns (bool isManaged, IERC20[] memory subCollaterals, bytes memory config);\\n\\n  /// @notice Returns the oracle values associated to `collateral`\\n  /// @return mint Oracle value to be used for a mint transaction with `collateral`\\n  /// @return burn Oracle value that will be used for `collateral` for a burn transaction. This value\\n  /// is then used along with oracle values for all other collateral assets to get a global burn value for the oracle\\n  /// @return ratio Ratio, in base `10**18` between the oracle value of the `collateral` and its target price.\\n  /// This value is 10**18 if the oracle is greater than the collateral price\\n  /// @return minRatio Minimum ratio across all collateral assets between a collateral burn price and its target\\n  /// price. This value is independent of `collateral` and is used to normalize the burn oracle value for burn\\n  /// transactions.\\n  /// @return redemption Oracle value that would be used to price `collateral` when computing the collateral ratio\\n  /// during a redemption\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption);\\n\\n  /// @notice Returns the data used to compute oracle values for `collateral`\\n  /// @return oracleType Type of oracle (Chainlink, external smart contract, ...)\\n  /// @return targetType Type passed to read the value of the target price\\n  /// @return oracleData Extra data needed to read the oracle. For Chainlink oracles, this data is supposed to give\\n  /// the addresses of the Chainlink feeds to read, the stale periods for each feed, ...\\n  /// @return targetData Extra data needed to read the target price of the asset\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    );\\n\\n  /// @notice Returns if the associated functionality is paused or not\\n  function isPaused(address collateral, ActionType action) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update normalizers\\n  function isTrusted(address sender) external view returns (bool);\\n\\n  /// @notice Returns if `sender` is trusted to update sell rewards\\n  function isTrustedSeller(address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` has a non null entry in the `isWhitelistedForType` storage mapping\\n  /// @dev Note that ultimately whitelisting may depend as well on external providers\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool);\\n\\n  /// @notice Checks whether `sender` can deal with `collateral` during burns and redemptions\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool);\\n\\n  /// @notice Checks whether only whitelisted address can deal with `collateral` during burns and redemptions\\n  function isWhitelistedCollateral(address collateral) external view returns (bool);\\n\\n  /// @notice Gets the data needed to deal with whitelists for `collateral`\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory);\\n\\n  /// @notice Returns the stablecoin cap for `collateral`\\n  function getStablecoinCap(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the address of the `accessManager` contract\\n  function accessManager() external view returns (address);\\n\\n  /// @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is\\n  /// being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs\\n  /// attacker controlled calls.\\n  function isConsumingScheduledOp() external view returns (bytes4);\\n\\n  /// @notice Returns the payees and their shares\\n  function getPayees() external view returns (address[] memory, uint256[] memory);\\n\\n  /// @notice Returns the total shares of the payees\\n  function getTotalShares() external view returns (uint256);\\n\\n  /// @notice Returns the shares of a payee\\n  function getShares(address payee) external view returns (uint256);\\n\\n  /// @notice Returns the last time the income was released to the payees\\n  function getLastReleasedAt() external view returns (uint256);\\n\\n  /// @notice Returns the slippage tolerance for a `collateral` for the surplus\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  function getSlippageTolerance(address collateral) external view returns (uint256);\\n\\n  /// @notice Returns the minimum collateral ratio that must hold after surplus processing\\n  /// @dev Expressed in base 1e9, and always >= 1e9\\n  /// @notice Returns the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  function getSwapRouter() external view returns (address);\\n\\n  function getSurplusBufferRatio() external view returns (uint64);\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus);\\n}\\n\",\"keccak256\":\"0x27a333b02ba124b5964a63bddeb301328197bddbe98538903cd41a8b40900d12\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Getters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IGetters } from \\\"contracts/interfaces/IGetters.sol\\\";\\n\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibSurplus } from \\\"../libraries/LibSurplus.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Getters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev There may be duplicates in the info provided by the getters defined here\\n/// @dev This contract is an authorized fork of Angle's `Getters` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Getters.sol\\ncontract Getters is IGetters {\\n  /// @inheritdoc IGetters\\n  function isValidSelector(bytes4 selector) external view returns (bool) {\\n    return s.diamondStorage().selectorInfo[selector].facetAddress != address(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function tokenP() external view returns (ITokenP) {\\n    return s.transmuterStorage().tokenP;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralList() external view returns (address[] memory) {\\n    return s.transmuterStorage().collateralList;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralInfo(address collateral) external view returns (Collateral memory) {\\n    return s.transmuterStorage().collaterals[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralDecimals(address collateral) external view returns (uint8) {\\n    return s.transmuterStorage().collaterals[collateral].decimals;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralMintFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeMint, int64[] memory yFeeMint)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeMint, collatInfo.yFeeMint);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralBurnFees(address collateral)\\n    external\\n    view\\n    returns (uint64[] memory xFeeBurn, int64[] memory yFeeBurn)\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.xFeeBurn, collatInfo.yFeeBurn);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getRedemptionFees()\\n    external\\n    view\\n    returns (uint64[] memory xRedemptionCurve, int64[] memory yRedemptionCurve)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (ts.xRedemptionCurve, ts.yRedemptionCurve);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function may revert and overflow if the collateral ratio is too big due to a too small\\n  /// amount of `stablecoinsIssued`. Due to this, it is recommended to initialize the system with a non\\n  /// negligible amount of `stablecoinsIssued` so DoS attacks on redemptions which use this function\\n  /// become economically impossible\\n  function getCollateralRatio() external view returns (uint64 collatRatio, uint256 stablecoinsIssued) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n\\n    (collatRatio, stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getIssuedByCollateral(address collateral)\\n    external\\n    view\\n    returns (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    return (\\n      (uint256(ts.collaterals[collateral].normalizedStables) * _normalizer) / BASE_27,\\n      (uint256(ts.normalizedStables) * _normalizer) / BASE_27\\n    );\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalIssued() external view returns (uint256) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    return (uint256(ts.normalizedStables) * uint256(ts.normalizer)) / BASE_27;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getManagerData(address collateral) external view returns (bool, IERC20[] memory, bytes memory) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      return (true, collatInfo.managerData.subCollaterals, collatInfo.managerData.config);\\n    }\\n    return (false, new IERC20[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is not optimized for gas consumption as for instance the `burn` value for collateral\\n  /// is computed twice: once in `readBurn` and once in `getBurnOracle`\\n  function getOracleValues(address collateral)\\n    external\\n    view\\n    returns (uint256 mint, uint256 burn, uint256 ratio, uint256 minRatio, uint256 redemption)\\n  {\\n    bytes memory oracleConfig = s.transmuterStorage().collaterals[collateral].oracleConfig;\\n    (burn, ratio) = LibOracle.readBurn(oracleConfig);\\n    (minRatio,) = LibOracle.getBurnOracle(collateral, oracleConfig);\\n    return (LibOracle.readMint(oracleConfig), burn, ratio, minRatio, LibOracle.readRedemption(oracleConfig));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getOracle(address collateral)\\n    external\\n    view\\n    returns (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    )\\n  {\\n    return LibOracle.getOracle(collateral);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isPaused(address collateral, ActionType action) external view returns (bool) {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      if (action == ActionType.Mint) {\\n        return collatInfo.isMintLive == 0;\\n      } else {\\n        return collatInfo.isBurnLive == 0;\\n      }\\n    } else {\\n      return s.transmuterStorage().isRedemptionLive == 0;\\n    }\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrusted(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isTrustedSeller(address sender) external view returns (bool) {\\n    return s.transmuterStorage().isSellerTrusted[sender] == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedForType(WhitelistType whitelistType, address sender) external view returns (bool) {\\n    return s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  /// @dev This function is non view as it may consult external non view functions from whitelist providers\\n  function isWhitelistedForCollateral(address collateral, address sender) external returns (bool) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    return (collatInfo.onlyWhitelisted == 0 || LibWhitelist.checkWhitelist(collatInfo.whitelistData, sender));\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isWhitelistedCollateral(address collateral) external view returns (bool) {\\n    return s.transmuterStorage().collaterals[collateral].onlyWhitelisted == 1;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralWhitelistData(address collateral) external view returns (bytes memory) {\\n    return s.transmuterStorage().collaterals[collateral].whitelistData;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getStablecoinCap(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().collaterals[collateral].stablecoinCap;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function accessManager() external view returns (address) {\\n    return address(s.diamondStorage().accessManager);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function isConsumingScheduledOp() external view returns (bytes4) {\\n    return s.transmuterStorage().consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getPayees() external view returns (address[] memory, uint256[] memory) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory payees = new address[](ts.payees.length);\\n    uint256[] memory shares = new uint256[](ts.payees.length);\\n    for (uint256 i = 0; i < ts.payees.length; i++) {\\n      payees[i] = ts.payees[i];\\n      shares[i] = ts.shares[ts.payees[i]];\\n    }\\n    return (payees, shares);\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getTotalShares() external view returns (uint256) {\\n    return s.transmuterStorage().totalShares;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getShares(address payee) external view returns (uint256) {\\n    return s.transmuterStorage().shares[payee];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSlippageTolerance(address collateral) external view returns (uint256) {\\n    return s.transmuterStorage().slippageTolerance[collateral];\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSwapRouter() external view returns (address) {\\n    return s.transmuterStorage().swapRouter;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getSurplusBufferRatio() external view returns (uint64) {\\n    return s.transmuterStorage().surplusBufferRatio;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getLastReleasedAt() external view returns (uint256) {\\n    return s.transmuterStorage().lastReleasedAt;\\n  }\\n\\n  /// @inheritdoc IGetters\\n  function getCollateralSurplus(address collateral)\\n    external\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    return LibSurplus._computeCollateralSurplus(collateral);\\n  }\\n}\\n\",\"keccak256\":\"0x7698420203383c245b91740b40652708e240877ec9d006d211556c7ffe0406e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -927,8 +941,8 @@
       "getStablecoinCap(address)": {
         "notice": "Returns the stablecoin cap for `collateral`"
       },
-      "getSurplusBufferRatio()": {
-        "notice": "Returns the minimum collateral ratio that must hold after surplus processing"
+      "getSwapRouter()": {
+        "notice": "Returns the minimum collateral ratio that must hold after surplus processingReturns the aggregator or DEX the `RewardHandler` forwards its swap payload to"
       },
       "getTotalIssued()": {
         "notice": "Returns the total amount of stablecoins issued through Parallelizer"
@@ -965,13 +979,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "nonce": "0xbe",
-    "hash": "0x7498172921a450125306b2ccf9320adaf7f0b1bbe872c5d0662f6d704ead962d",
+    "nonce": "0xd9",
+    "hash": "0xf564436c225cb75aae77314a87593b13809951ecbf69d083cc270f94fb589582",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
-    "blockHash": "0xcb5e8c5c5eff389b69723f8bf2701b4ff4a13e24f919c95c0c686081bf66bbf0",
-    "blockNumber": "0x2765cbd",
-    "transactionIndex": "0x4"
+    "blockHash": "0x2b5fe74008daf924b8cdceb735201cd7bf072ca3d508f3c21b8672c422b40d07",
+    "blockNumber": "0x2e5a02d",
+    "transactionIndex": "0x2"
   }
 }
\ No newline at end of file
diff --git a/deployments/hyperevm/Redeemer.json b/deployments/hyperevm/Redeemer.json
index 056926f..9b212b4 100644
--- a/deployments/hyperevm/Redeemer.json
+++ b/deployments/hyperevm/Redeemer.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x15df158044cbc28d31cde8b754f19856571dc169",
+  "address": "0xe2642f5bb0ea193918f50cd8cd8f427a0b6b88d3",
   "abi": [
     {
       "inputs": [],
@@ -78,6 +78,11 @@
       "name": "TooSmallAmountOut",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "UnexpectedRedemptionTokens",
+      "type": "error"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -179,6 +184,11 @@
           "internalType": "uint256[]",
           "name": "minAmountOuts",
           "type": "uint256[]"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
         }
       ],
       "name": "redeem",
@@ -224,6 +234,11 @@
           "name": "forfeitTokens",
           "type": "address[]"
         },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
+        },
         {
           "internalType": "bytes",
           "name": "authData",
@@ -272,6 +287,11 @@
           "internalType": "address[]",
           "name": "forfeitTokens",
           "type": "address[]"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "expectedTokensHash",
+          "type": "bytes32"
         }
       ],
       "name": "redeemWithForfeit",
@@ -317,8 +337,8 @@
   ],
   "contractName": "Redeemer",
   "sourceName": "contracts/parallelizer/facets/Redeemer.sol",
-  "bytecode": "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",
-  "deployedBytecode": "0x608060405234801561000f575f5ffd5b5060043610610064575f3560e01c8063815822c11161004d578063815822c1146100a5578063d703a0cd146100b8578063fd7daaf8146100cb575f5ffd5b80632e7639bc1461006857806356018dc014610092575b5f5ffd5b61007b610076366004612c7a565b6100ec565b604051610089929190612d76565b60405180910390f35b61007b6100a0366004612dc1565b61011a565b61007b6100b3366004612eae565b61013a565b61007b6100c6366004612f0d565b610190565b6100de6100d9366004612f31565b6101a7565b604051908152602001610089565b60608061010b878787878760405180602001604052805f815250610235565b915091505b9550959350505050565b60608061012b888888888888610235565b91509150965096945050505050565b606080610183868686865f60405190808252806020026020018201604052801561016e578160200160208202803683370190505b5060405180602001604052805f815250610235565b9150915094509492505050565b60608061019c836104e2565b509094909350915050565b5f6101b3335f36610793565b1580156101eb5750335f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7b6020526040902054155b15610222576040517fc22a648e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b61022c83836108cc565b90505b92915050565b5f516020613a075f395f51905f528054606091829160ff600160a81b909104166001190161028f576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff60a81b191675020000000000000000000000000000000000000000001781555f516020613a075f395f51905f525474010000000000000000000000000000000000000000900460ff165f03610314576040517f9e87fac800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8642111561034e576040517fecdd1c2900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103a56040518061010001604052805f81526020015f6001600160a01b031681526020015f6001600160a01b0316815260200160608152602001606081526020016060815260200160608152602001606081525090565b8981526001600160a01b038916604082015260c0810187905260e081018690526103ce8a6104e2565b60a0840152608083018190526060830191909152875190511461041d576040517f1df89e8b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6104278a5f6108cc565b506104368a8a8a8a8a8a610c16565b6001600160a01b0316602082015261044d81610d14565b80604001516001600160a01b031681602001516001600160a01b03167f3998bcf315dae4953d294b3ca6e1d0074c249adc136b50d1ff99b04753c73e7f835f0151846060015185608001518660e001516040516104ad9493929190612f5f565b60405180910390a3806060015181608001519350935050805460ff60a81b1916600160a81b1790559097909650945050505050565b60608060605f5f6104f1611134565b91985096509450909250905080861061051c5760405162839e0f60e81b815260040160405180910390fd5b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c798054604080516020808402820181019092528281525f516020613a075f395f51905f52935f9391929091908301828280156105b757602002820191905f5260205f20905f905b825461010083900a900460070b81526020600f83018190049384019360010360089093019290920291018084116105835790505b505050505090505f633b9aca008567ffffffffffffffff16101561066b575f8360030180548060200260200160405190810160405280929190818152602001828054801561065557602002820191905f5260205f20905f905b82829054906101000a900467ffffffffffffffff1667ffffffffffffffff16815260200190600801906020826007010492830192600103820291508084116106105790505b5050505050905061066786828561177b565b9150505b5f5b875181101561078657633b9aca008667ffffffffffffffff1610156106e35761069a633b9aca0086612fb1565b8267ffffffffffffffff168983815181106106b7576106b7612fc8565b60200260200101518c6106ca9190612fb1565b6106d49190612fb1565b6106de9190612ff0565b610761565b6106f767ffffffffffffffff871686612fb1565b83600185516107069190613003565b8151811061071657610716612fc8565b602002602001015167ffffffffffffffff1689838151811061073a5761073a612fc8565b60200260200101518c61074d9190612fb1565b6107579190612fb1565b6107619190612ff0565b88828151811061077357610773612fc8565b602090810291909101015260010161066d565b5050505050509193909250565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d545f906001600160a01b031681806107e38388306107d56004868b8d613016565b6107de9161303d565b61191b565b91509150816108bd5763ffffffff8116156108b2575f516020613a075f395f51905f52805460ff60b01b19167601000000000000000000000000000000000000000000001781556040517f94c7d7ee0000000000000000000000000000000000000000000000000000000081526001600160a01b038516906394c7d7ee90610873908b908b908b906004016130a3565b5f604051808303815f87803b15801561088a575f5ffd5b505af115801561089c573d5f5f3e3d5ffd5b5050825460ff60b01b1916909255506108bd9050565b5f93505050506108c5565b600193505050505b9392505050565b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c76545f905f516020613a075f395f51905f52906001600160801b03600160801b820481169116841561094a578061092f6b033b2e3c9fd0803ce800000088612fb1565b6109399190612ff0565b61094390836130e1565b9350610978565b806109616b033b2e3c9fd0803ce800000088612fb1565b61096b9190612ff0565b6109759083613003565b93505b670de0b6b3a76400008411158061099e57506ec097ce7bc90715b34b9f10000000008410155b15610b7c575f836002018054806020026020016040519081016040528092919081815260200182805480156109fa57602002820191905f5260205f20905b81546001600160a01b031681526001909101906020018083116109dc575b505050505090505f815190505f5f5b82811015610b2f575f610a9c6b033b2e3c9fd0803ce80000008a8a6005015f898781518110610a3a57610a3a612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f2054610a8d91906501000000000090047affffffffffffffffffffffffffffffffffffffffffffffffffffff16612fb1565b610a979190612ff0565b6119f3565b9050610aa881846130f4565b9250806001600160801b0316886005015f878581518110610acb57610acb612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f2080547affffffffffffffffffffffffffffffffffffffffffffffffffffff92909216650100000000000264ffffffffff90921691909117905550600101610a09565b506001860180547fffffffffffffffffffffffffffffffff00000000000000000000000000000000166001600160801b0392909216919091179055506b033b2e3c9fd0803ce80000009450505b610b85846119f3565b6001840180546001600160801b03928316600160801b02921691909117905584158015610bbd575060018301546001600160801b0316155b15610bda5760405162839e0f60e81b815260040160405180910390fd5b6040518481527fb4fde7403c001c7cdeafc0c3bb46e972111b7efac4e832398cbf9fabe1694ed99060200160405180910390a150505092915050565b5f516020613a075f395f51905f525481515f916001600160a01b03169015610ca957610c46888888888888611a2f565b6040516315a38ec760e11b8152600481018a90523060248201529092506001600160a01b03821690632b471d8e906044015f604051808303815f87803b158015610c8e575f5ffd5b505af1158015610ca0573d5f5f3e3d5ffd5b50505050610d09565b6040516315a38ec760e11b815260048101899052336024820181905292506001600160a01b03821690632b471d8e906044015f604051808303815f87803b158015610cf2575f5ffd5b505af1158015610d04573d5f5f3e3d5ffd5b505050505b509695505050505050565b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c778054604080516020808402820181019092528281525f516020613a075f395f51905f52935f939192909190830182828015610d9757602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610d79575b505050505090505f5f84608001515190505f5b8181101561112c578560c001518181518110610dc857610dc8612fc8565b602002602001015186608001518281518110610de657610de6612fc8565b60200260200101511015610e26576040517fa1aabbe100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f86608001518281518110610e3d57610e3d612fc8565b6020026020010151118015610e7b57505f610e7987606001518381518110610e6757610e67612fc8565b60200260200101518860e00151611b4b565b125b156110e8575f856005015f868681518110610e9857610e98612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f208054909150640100000000900460ff1615801590610f6d5750610f6b816006018054610ee590613113565b80601f0160208091040260200160405190810160405280929190818152602001828054610f1190613113565b8015610f5c5780601f10610f3357610100808354040283529160200191610f5c565b820191905f5260205f20905b815481529060010190602001808311610f3f57829003601f168201915b50505050508860400151611ba7565b155b15610fa4576040517f584a793800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff161561108a5761108587606001518381518110610fc757610fc7612fc8565b6020026020010151886040015189608001518581518110610fea57610fea612fc8565b602002602001015184600701600101805461100490613113565b80601f016020809104026020016040519081016040528092919081815260200182805461103090613113565b801561107b5780601f106110525761010080835404028352916020019161107b565b820191905f5260205f20905b81548152906001019060200180831161105e57829003601f168201915b5050505050611d18565b6110e6565b6110e68760400151886080015184815181106110a8576110a8612fc8565b6020026020010151896060015185815181106110c6576110c6612fc8565b60200260200101516001600160a01b0316611dd99092919063ffffffff16565b505b8060018760a00151858151811061110157611101612fc8565b60200260200101516111139190613003565b11611124576111218361314b565b92505b600101610daa565b505050505050565b5f8060608080835f516020613a075f395f51905f5290505f5f826002018054806020026020016040519081016040528092919081815260200182805480156111a357602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311611185575b505050505090505f815190505f8167ffffffffffffffff8111156111c9576111c9612b1b565b6040519080825280602002602001820160405280156111f2578160200160208202803683370190505b5095505f5b828110156112c457856005015f85838151811061121657611216612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f9081205460ff1690036112545761124d8261314b565b915061129e565b856005015f85838151811061126b5761126b612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f206007015461129b90836130e1565b91505b818782815181106112b1576112b1612fc8565b60209081029190910101526001016111f7565b508067ffffffffffffffff8111156112de576112de612b1b565b604051908082528060200260200182016040528015611307578160200160208202803683370190505b5096508067ffffffffffffffff81111561132357611323612b1b565b60405190808252806020026020018201604052801561134c578160200160208202803683370190505b5097505f5f5b83811015611707575f876005015f87848151811061137257611372612fc8565b6020908102919091018101516001600160a01b031682528101919091526040015f908120805490925060ff161561151057606061143b8360070160010180546113ba90613113565b80601f01602080910402602001604051908101604052809291908181526020018280546113e690613113565b80156114315780601f1061140857610100808354040283529160200191611431565b820191905f5260205f20905b81548152906001019060200180831161141457829003601f168201915b5050505050611e5e565b81519093509091505f5b818110156114fc576007850180548290811061146357611463612fc8565b5f918252602090912001546001600160a01b03168f611482838a6130e1565b8151811061149257611492612fc8565b60200260200101906001600160a01b031690816001600160a01b0316815250508281815181106114c4576114c4612fc8565b60200260200101518e82896114d991906130e1565b815181106114e9576114e9612fc8565b6020908102919091010152600101611445565b5061150781876130e1565b9550505061161e565b86838151811061152257611522612fc8565b60209081029190910101516040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa158015611589573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906115ad9190613163565b90508683815181106115c1576115c1612fc8565b60200260200101518c85815181106115db576115db612fc8565b6001600160a01b0390921660209283029190910190910152808b856115ff8161314b565b96508151811061161157611611612fc8565b6020026020010181815250505b5f6116b283600501805461163190613113565b80601f016020809104026020016040519081016040528092919081815260200182805461165d90613113565b80156116a85780601f1061167f576101008083540402835291602001916116a8565b820191905f5260205f20905b81548152906001019060200180831161168b57829003601f168201915b5050505050611f0d565b8354909150670de0b6b3a7640000906116d99084906301000000900460ff1660125f611fce565b6116e39083612fb1565b6116ed9190612ff0565b6116f7908a6130e1565b9850505050806001019050611352565b505060018086015461173b916001600160801b0380831692600160801b900416906b033b2e3c9fd0803ce800000090612049565b985088156117635761175c61175785633b9aca008c6001612049565b61208b565b995061176f565b67ffffffffffffffff99505b50505050509091929394565b5f5f61178b6001856001886120c1565b9050801580156117c75750835f815181106117a8576117a8612fc8565b602002602001015167ffffffffffffffff168567ffffffffffffffff16105b156117ee57825f815181106117de576117de612fc8565b60200260200101519150506108c5565b600184516117fc9190613003565b81036118215782600185516118119190613003565b815181106117de576117de612fc8565b83818151811061183357611833612fc8565b60200260200101518482600161184991906130e1565b8151811061185957611859612fc8565b602002602001015161186b919061317a565b84828151811061187d5761187d612fc8565b602002602001015186611890919061317a565b8483815181106118a2576118a2612fc8565b6020026020010151858460016118b891906130e1565b815181106118c8576118c8612fc8565b60200260200101516118da919061319a565b6118e491906131c9565b6118ee91906131e8565b83828151811061190057611900612fc8565b60200260200101516119129190613225565b95945050505050565b6040516001600160a01b038085166024830152831660448201527fffffffff00000000000000000000000000000000000000000000000000000000821660648201525f908190819060840160408051601f19818403018152918152602080830180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fb7009613000000000000000000000000000000000000000000000000000000001781525f808052918290528351939450919290918a5afa156119e9575f516020805191945081901c150291505b5094509492505050565b5f6001600160801b03821115611a2b576040516306dfcc6560e41b815260806004820152602481018390526044015b60405180910390fd5b5090565b5f5f82806020019051810190611a4591906132a1565b905087816020015114611a84576040517f1115766700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f611a9b825f01518a8a8a8a8a8860800151612256565b5f516020613a075f395f51905f525483516020850151604080870151606088015160a089015192517f88b7ab630000000000000000000000000000000000000000000000000000000081529697506001600160a01b03909516956388b7ab6395611b10959430949093928a9190600401613348565b5f604051808303815f87803b158015611b27575f5ffd5b505af1158015611b39573d5f5f3e3d5ffd5b505092519a9950505050505050505050565b80515f90815b81811015611b9c57838181518110611b6b57611b6b612fc8565b60200260200101516001600160a01b0316856001600160a01b031603611b9457915061022f9050565b600101611b51565b505f19949350505050565b5f5f5f84806020019051810190611bbe91906133c8565b915091505f611bd75f516020613a075f395f51905f5290565b6008015f848015611bea57611bea613416565b8015611bf857611bf8613416565b81526020019081526020015f205f866001600160a01b03166001600160a01b031681526020019081526020015f20541115611c385760019250505061022f565b805115611d0e575f828015611c4f57611c4f613416565b03611d0e575f81806020019051810190611c69919061342a565b90506001600160a01b03811615611d0c576040517f65e4ad9e0000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b0386811660248301528216906365e4ad9e906044016020604051808303815f875af1158015611cde573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611d029190613445565b935050505061022f565b505b505f949350505050565b5f5f611d2383612339565b90925090505f828015611d3857611d38613416565b0361112c5780806020019051810190611d51919061342a565b6040517f8bfb07c90000000000000000000000000000000000000000000000000000000081526001600160a01b0388811660048301528781166024830152604482018790529190911690638bfb07c9906064015f604051808303815f87803b158015611dbb575f5ffd5b505af1158015611dcd573d5f5f3e3d5ffd5b50505050505050505050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052611e5990849061235a565b505050565b60605f5f5f611e6c85612339565b90925090505f828015611e8157611e81613416565b03611f065780806020019051810190611e9a919061342a565b6001600160a01b03166301e1d1146040518163ffffffff1660e01b81526004015f60405180830381865afa158015611ed4573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f19168201604052611efb9190810190613460565b935093505050915091565b5050915091565b5f5f5f5f5f611f1b866123e5565b50929650909450925090506001846009811115611f3a57611f3a613416565b03611fc1575f82806020019051810190611f54919061342a565b9050806001600160a01b0316636256f2c56040518163ffffffff1660e01b8152600401602060405180830381865afa158015611f92573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611fb69190613163565b979650505050505050565b610d09848484845f612412565b5f8260ff168460ff16111561200a575f611fe884866134fb565b611ff390600a6135f7565b90506120028660018386612049565b915050612041565b8260ff168460ff16101561203e5761202284846134fb565b61202d90600a6135f7565b6120379086612fb1565b9050612041565b50835b949350505050565b5f612076612056836124ad565b801561207157505f848061206c5761206c612fdc565b868809115b151590565b6120818686866124d9565b61191291906130e1565b5f67ffffffffffffffff821115611a2b57604080516306dfcc6560e41b8152600481019190915260248101839052604401611a22565b5f83515f036120d157505f612041565b8351600190868015612125575067ffffffffffffffff841685876120f6600185613003565b8151811061210657612106612fc8565b60200260200101516121189190613605565b67ffffffffffffffff1611155b8061217b57508615801561217b575067ffffffffffffffff8416858761214c600185613003565b8151811061215c5761215c612fc8565b602002602001015161216e9190613605565b67ffffffffffffffff1610155b156121945761218b600182613003565b92505050612041565b8082101561224b575f6121a78383612589565b9050876121ee578467ffffffffffffffff16868883815181106121cc576121cc612fc8565b60200260200101516121de9190613605565b67ffffffffffffffff161061222a565b8467ffffffffffffffff168688838151811061220c5761220c612fc8565b602002602001015161221e9190613605565b67ffffffffffffffff16115b1561223757809150612245565b6122428160016130e1565b92505b50612194565b611fb6600183613003565b5f7fcff34e096e1842f6f6ae4c0d0c6eefd4855c8bdc5bc64155d7c14b2dbeee661a5f1b888888888860405160200161228f9190613628565b60405160208183030381529060405280519060200120886040516020016122b6919061365d565b60408051601f198184030181528282528051602091820120908301989098526001600160a01b0396871690820152606081019490945293909116608083015260a082015260c081019190915260e0810191909152610100810183905261012001604051602081830303815290604052805190602001209050979650505050505050565b5f60608280602001905181019061235091906133c8565b9094909350915050565b5f5f60205f8451602086015f885af180612379576040513d5f823e3d81fd5b50505f513d9150811561239057806001141561239d565b6001600160a01b0384163b155b156123df576040517f5274afe70000000000000000000000000000000000000000000000000000000081526001600160a01b0385166004820152602401611a22565b50505050565b5f5f60608060608580602001905181019061240091906136a3565b939a9299509097509550909350915050565b5f5f61242786670de0b6b3a7640000866125a3565b90506124348782876125a3565b9150612448670de0b6b3a764000083612fb1565b61245a84670de0b6b3a7640000613003565b6124649083612fb1565b10801561249c575061247e83670de0b6b3a76400006130e1565b6124889082612fb1565b61249a670de0b6b3a764000084612fb1565b105b156101105796879650945050505050565b5f60028260038111156124c2576124c2613416565b6124cc9190613745565b60ff166001149050919050565b5f5f5f6124e686866129a1565b91509150815f0361250a5783818161250057612500612fdc565b04925050506108c5565b8184116125215761252160038515026011186129bd565b5f848688095f868103871696879004966002600389028118808a02820302808a02820302808a02820302808a02820302808a02820302808a02909103029181900381900460010185841190960395909502919093039390930492909217029150509392505050565b5f6125976002848418612ff0565b61022c908484166130e1565b5f808460098111156125b7576125b7613416565b03612687575f5f5f5f5f868060200190518101906125d59190613849565b945094509450945094505f6125ea828a6129ce565b86519091505f5b818110156126775761266d8389838151811061260f5761260f612fc8565b602002602001015188848151811061262957612629612fc8565b602002602001015188858151811061264357612643612fc8565b602002602001015160ff168b868151811061266057612660612fc8565b60200260200101516129fd565b92506001016125f1565b50819750505050505050506108c5565b600384600981111561269b5761269b613416565b036126af5750670de0b6b3a76400006108c5565b60028460098111156126c3576126c3613416565b036126cf5750816108c5565b60048460098111156126e3576126e3613416565b03612781576040517f7a28fb88000000000000000000000000000000000000000000000000000000008152670de0b6b3a7640000600482015273ae7ab96520de3a18e5e111b5eaab095312d7fe8490637a28fb8890602401602060405180830381865afa158015612756573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061277a9190613163565b90506108c5565b600584600981111561279557612795613416565b036127ea5773be9895146f7af43049ca1c1ae358b0541ea497046001600160a01b0316633ba0b9a96040518163ffffffff1660e01b8152600401602060405180830381865afa158015612756573d5f5f3e3d5ffd5b60068460098111156127fe576127fe613416565b036128535773ae78736cd615f374d3085123a210448e74fc63936001600160a01b031663e6aa216c6040518163ffffffff1660e01b8152600401602060405180830381865afa158015612756573d5f5f3e3d5ffd5b600784600981111561286757612867613416565b036128bc5773ac3e018457b222d93114458476f3e3416abbe38f6001600160a01b03166399530b066040518163ffffffff1660e01b8152600401602060405180830381865afa158015612756573d5f5f3e3d5ffd5b60088460098111156128d0576128d0613416565b036128f3575f828060200190518101906128ea9190613163565b91506108c59050565b600984600981111561290757612907613416565b0361299a575f5f838060200190518101906129229190613974565b9150915080826001600160a01b031663a035b1fe6040518163ffffffff1660e01b8152600401602060405180830381865afa158015612963573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906129879190613163565b6129919190612ff0565b925050506108c5565b50816108c5565b5f805f1983850993909202808410938190039390930393915050565b634e487b715f52806020526024601cfd5b5f808360018111156129e2576129e2613416565b036129f65750670de0b6b3a764000061022f565b508061022f565b5f5f5f866001600160a01b031663feaf968c6040518163ffffffff1660e01b815260040160a060405180830381865afa158015612a3c573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612a6091906139b9565b509350509250505f82131580612a84575063ffffffff8416612a828242613003565b115b15612abb576040517fae19356300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8560ff16600103612aee57612ad185600a6139fb565b612adb838a612fb1565b612ae59190612ff0565b92505050611912565b81612afa86600a6139fb565b612adb908a612fb1565b6001600160a01b0381168114612b18575f5ffd5b50565b634e487b7160e01b5f52604160045260245ffd5b60405160c0810167ffffffffffffffff81118282101715612b5257612b52612b1b565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715612b8157612b81612b1b565b604052919050565b5f67ffffffffffffffff821115612ba257612ba2612b1b565b5060051b60200190565b5f82601f830112612bbb575f5ffd5b8135612bce612bc982612b89565b612b58565b8082825260208201915060208360051b860101925085831115612bef575f5ffd5b602085015b83811015612c0c578035835260209283019201612bf4565b5095945050505050565b5f82601f830112612c25575f5ffd5b8135612c33612bc982612b89565b8082825260208201915060208360051b860101925085831115612c54575f5ffd5b602085015b83811015612c0c578035612c6c81612b04565b835260209283019201612c59565b5f5f5f5f5f60a08688031215612c8e575f5ffd5b853594506020860135612ca081612b04565b935060408601359250606086013567ffffffffffffffff811115612cc2575f5ffd5b612cce88828901612bac565b925050608086013567ffffffffffffffff811115612cea575f5ffd5b612cf688828901612c16565b9150509295509295909350565b5f8151808452602084019350602083015f5b82811015612d3c5781516001600160a01b0316865260209586019590910190600101612d15565b5093949350505050565b5f8151808452602084019350602083015f5b82811015612d3c578151865260209586019590910190600101612d58565b604081525f612d886040830185612d03565b82810360208401526119128185612d46565b5f67ffffffffffffffff821115612db357612db3612b1b565b50601f01601f191660200190565b5f5f5f5f5f5f60c08789031215612dd6575f5ffd5b863595506020870135612de881612b04565b945060408701359350606087013567ffffffffffffffff811115612e0a575f5ffd5b612e1689828a01612bac565b935050608087013567ffffffffffffffff811115612e32575f5ffd5b612e3e89828a01612c16565b92505060a087013567ffffffffffffffff811115612e5a575f5ffd5b8701601f81018913612e6a575f5ffd5b8035612e78612bc982612d9a565b8181528a6020838501011115612e8c575f5ffd5b816020840160208301375f602083830101528093505050509295509295509295565b5f5f5f5f60808587031215612ec1575f5ffd5b843593506020850135612ed381612b04565b925060408501359150606085013567ffffffffffffffff811115612ef5575f5ffd5b612f0187828801612bac565b91505092959194509250565b5f60208284031215612f1d575f5ffd5b5035919050565b8015158114612b18575f5ffd5b5f5f60408385031215612f42575f5ffd5b823591506020830135612f5481612f24565b809150509250929050565b848152608060208201525f612f776080830186612d03565b8281036040840152612f898186612d46565b90508281036060840152611fb68185612d03565b634e487b7160e01b5f52601160045260245ffd5b808202811582820484141761022f5761022f612f9d565b634e487b7160e01b5f52603260045260245ffd5b634e487b7160e01b5f52601260045260245ffd5b5f82612ffe57612ffe612fdc565b500490565b8181038181111561022f5761022f612f9d565b5f5f85851115613024575f5ffd5b83861115613030575f5ffd5b5050820193919092039150565b80357fffffffff00000000000000000000000000000000000000000000000000000000811690600484101561309c577fffffffff00000000000000000000000000000000000000000000000000000000808560040360031b1b82161691505b5092915050565b6001600160a01b038416815260406020820152816040820152818360608301375f818301606090810191909152601f909201601f1916010192915050565b8082018082111561022f5761022f612f9d565b6001600160801b03818116838216019081111561022f5761022f612f9d565b600181811c9082168061312757607f821691505b60208210810361314557634e487b7160e01b5f52602260045260245ffd5b50919050565b5f6001820161315c5761315c612f9d565b5060010190565b5f60208284031215613173575f5ffd5b5051919050565b67ffffffffffffffff828116828216039081111561022f5761022f612f9d565b600782810b9082900b03677fffffffffffffff198112677fffffffffffffff8213171561022f5761022f612f9d565b5f8260070b8260070b028060070b915080821461309c5761309c612f9d565b5f8160070b8360070b806131fe576131fe612fdc565b677fffffffffffffff1982145f198214161561321c5761321c612f9d565b90059392505050565b600781810b9083900b01677fffffffffffffff8113677fffffffffffffff198212171561022f5761022f612f9d565b5f82601f830112613263575f5ffd5b8151613271612bc982612d9a565b818152846020838601011115613285575f5ffd5b8160208501602083015e5f918101602001919091529392505050565b5f602082840312156132b1575f5ffd5b815167ffffffffffffffff8111156132c7575f5ffd5b820160c081850312156132d8575f5ffd5b6132e0612b2f565b81516132eb81612b04565b81526020828101519082015260408083015190820152606080830151908201526080808301519082015260a082015167ffffffffffffffff81111561332e575f5ffd5b61333a86828501613254565b60a083015250949350505050565b6001600160a01b03881681526001600160a01b03871660208201528560408201528460608201528360808201528260a082015260e060c08201525f82518060e0840152806020850161010085015e5f6101008285010152610100601f19601f83011684010191505098975050505050505050565b60018110612b18575f5ffd5b5f5f604083850312156133d9575f5ffd5b82516133e4816133bc565b602084015190925067ffffffffffffffff811115613400575f5ffd5b61340c85828601613254565b9150509250929050565b634e487b7160e01b5f52602160045260245ffd5b5f6020828403121561343a575f5ffd5b81516108c581612b04565b5f60208284031215613455575f5ffd5b81516108c581612f24565b5f5f60408385031215613471575f5ffd5b825167ffffffffffffffff811115613487575f5ffd5b8301601f81018513613497575f5ffd5b80516134a5612bc982612b89565b8082825260208201915060208360051b8501019250878311156134c6575f5ffd5b6020840193505b828410156134e85783518252602093840193909101906134cd565b6020969096015195979596505050505050565b60ff828116828216039081111561022f5761022f612f9d565b6001815b600184111561354f5780850481111561353357613533612f9d565b600184161561354157908102905b60019390931c928002613518565b935093915050565b5f826135655750600161022f565b8161357157505f61022f565b81600181146135875760028114613591576135ad565b600191505061022f565b60ff8411156135a2576135a2612f9d565b50506001821b61022f565b5060208310610133831016604e8410600b84101617156135d0575081810a61022f565b6135dc5f198484613514565b805f19048211156135ef576135ef612f9d565b029392505050565b5f61022c60ff841683613557565b67ffffffffffffffff818116838216029081169081811461309c5761309c612f9d565b81515f90829060208501835b82811015613652578151845260209384019390910190600101613634565b509195945050505050565b81515f90829060208501835b828110156136525781516001600160a01b0316845260209384019390910190600101613669565b8051600a811061369e575f5ffd5b919050565b5f5f5f5f5f60a086880312156136b7575f5ffd5b6136c086613690565b94506136ce60208701613690565b9350604086015167ffffffffffffffff8111156136e9575f5ffd5b6136f588828901613254565b935050606086015167ffffffffffffffff811115613711575f5ffd5b61371d88828901613254565b925050608086015167ffffffffffffffff811115613739575f5ffd5b612cf688828901613254565b5f60ff83168061375757613757612fdc565b8060ff84160691505092915050565b5f82601f830112613775575f5ffd5b8151613783612bc982612b89565b8082825260208201915060208360051b8601019250858311156137a4575f5ffd5b602085015b83811015612c0c57805163ffffffff811681146137c4575f5ffd5b8352602092830192016137a9565b5f82601f8301126137e1575f5ffd5b81516137ef612bc982612b89565b8082825260208201915060208360051b860101925085831115613810575f5ffd5b602085015b83811015612c0c57805160ff8116811461382d575f5ffd5b835260209283019201613815565b80516002811061369e575f5ffd5b5f5f5f5f5f60a0868803121561385d575f5ffd5b855167ffffffffffffffff811115613873575f5ffd5b8601601f81018813613883575f5ffd5b8051613891612bc982612b89565b8082825260208201915060208360051b85010192508a8311156138b2575f5ffd5b6020840193505b828410156138dd5783516138cc81612b04565b8252602093840193909101906138b9565b80985050505050602086015167ffffffffffffffff8111156138fd575f5ffd5b61390988828901613766565b945050604086015167ffffffffffffffff811115613925575f5ffd5b613931888289016137d2565b935050606086015167ffffffffffffffff81111561394d575f5ffd5b613959888289016137d2565b9250506139686080870161383b565b90509295509295909350565b5f5f60408385031215613985575f5ffd5b825161399081612b04565b6020939093015192949293505050565b805169ffffffffffffffffffff8116811461369e575f5ffd5b5f5f5f5f5f60a086880312156139cd575f5ffd5b6139d6866139a0565b60208701516040880151606089015192975090955093509150613968608087016139a0565b5f61022c838361355756fe4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75a2646970667358221220adec1ca214a5a3cf42d22772187300cfb66c2131f2ea0b391dd08d79bc15ddb564736f6c634300081c0033",
+  "bytecode": "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",
+  "deployedBytecode": "0x608060405234801561000f575f5ffd5b5060043610610064575f3560e01c8063d703a0cd1161004d578063d703a0cd146100a5578063f70125ab146100b8578063fd7daaf8146100cb575f5ffd5b80632c1918f914610068578063b521934614610092575b5f5ffd5b61007b610076366004612cf8565b6100ec565b604051610089929190612dfe565b60405180910390f35b61007b6100a0366004612e22565b61011b565b61007b6100b3366004612e88565b610174565b61007b6100c6366004612f13565b61018b565b6100de6100d9366004612fdc565b6101ad565b604051908152602001610089565b60608061010c88888888888860405180602001604052805f81525061023b565b91509150965096945050505050565b606080610165878787875f60405190808252806020026020018201604052801561014f578160200160208202803683370190505b508860405180602001604052805f81525061023b565b915091505b9550959350505050565b6060806101808361054d565b509094909350915050565b60608061019d8989898989898961023b565b9150915097509795505050505050565b5f6101b9335f366107fe565b1580156101f15750335f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7b6020526040902054155b15610228576040517fc22a648e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6102328383610937565b90505b92915050565b5f516020613abf5f395f51905f528054606091829160ff600160a81b9091041660011901610295576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff60a81b191675020000000000000000000000000000000000000000001781555f516020613abf5f395f51905f525474010000000000000000000000000000000000000000900460ff165f0361031a576040517f9e87fac800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b87421115610354576040517fecdd1c2900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6103ab6040518061010001604052805f81526020015f6001600160a01b031681526020015f6001600160a01b0316815260200160608152602001606081526020016060815260200160608152602001606081525090565b8a81526001600160a01b038a16604082015260c0810188905260e081018790526103d48b61054d565b60a08401526080830181905260608301919091528851905114610423576040517f1df89e8b00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b858160600151604051602001610439919061300a565b6040516020818303038152906040528051906020012014610486576040517f580e8a7900000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b6104908b5f610937565b506104a08b8b8b8b8b8b8b610c81565b6001600160a01b031660208201526104b781610d81565b80604001516001600160a01b031681602001516001600160a01b03167f3998bcf315dae4953d294b3ca6e1d0074c249adc136b50d1ff99b04753c73e7f835f0151846060015185608001518660e001516040516105179493929190613048565b60405180910390a3806060015181608001519350935050805460ff60a81b1916600160a81b179055909890975095505050505050565b60608060605f5f61055c6111a1565b9198509650945090925090508086106105875760405162839e0f60e81b815260040160405180910390fd5b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c798054604080516020808402820181019092528281525f516020613abf5f395f51905f52935f93919290919083018282801561062257602002820191905f5260205f20905f905b825461010083900a900460070b81526020600f83018190049384019360010360089093019290920291018084116105ee5790505b505050505090505f633b9aca008567ffffffffffffffff1610156106d6575f836003018054806020026020016040519081016040528092919081815260200182805480156106c057602002820191905f5260205f20905f905b82829054906101000a900467ffffffffffffffff1667ffffffffffffffff168152602001906008019060208260070104928301926001038202915080841161067b5790505b505050505090506106d28682856117e8565b9150505b5f5b87518110156107f157633b9aca008667ffffffffffffffff16101561074e57610705633b9aca008661309a565b8267ffffffffffffffff16898381518110610722576107226130b1565b60200260200101518c610735919061309a565b61073f919061309a565b61074991906130d9565b6107cc565b61076267ffffffffffffffff87168661309a565b836001855161077191906130ec565b81518110610781576107816130b1565b602002602001015167ffffffffffffffff168983815181106107a5576107a56130b1565b60200260200101518c6107b8919061309a565b6107c2919061309a565b6107cc91906130d9565b8882815181106107de576107de6130b1565b60209081029190910101526001016106d8565b5050505050509193909250565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d545f906001600160a01b0316818061084e8388306108406004868b8d6130ff565b61084991613126565b611988565b91509150816109285763ffffffff81161561091d575f516020613abf5f395f51905f52805460ff60b01b19167601000000000000000000000000000000000000000000001781556040517f94c7d7ee0000000000000000000000000000000000000000000000000000000081526001600160a01b038516906394c7d7ee906108de908b908b908b9060040161318c565b5f604051808303815f87803b1580156108f5575f5ffd5b505af1158015610907573d5f5f3e3d5ffd5b5050825460ff60b01b1916909255506109289050565b5f9350505050610930565b600193505050505b9392505050565b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c76545f905f516020613abf5f395f51905f52906001600160801b03600160801b82048116911684156109b5578061099a6b033b2e3c9fd0803ce80000008861309a565b6109a491906130d9565b6109ae90836131ca565b93506109e3565b806109cc6b033b2e3c9fd0803ce80000008861309a565b6109d691906130d9565b6109e090836130ec565b93505b670de0b6b3a764000084111580610a0957506ec097ce7bc90715b34b9f10000000008410155b15610be7575f83600201805480602002602001604051908101604052809291908181526020018280548015610a6557602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610a47575b505050505090505f815190505f5f5b82811015610b9a575f610b076b033b2e3c9fd0803ce80000008a8a6005015f898781518110610aa557610aa56130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f2054610af891906501000000000090047affffffffffffffffffffffffffffffffffffffffffffffffffffff1661309a565b610b0291906130d9565b611a60565b9050610b1381846131dd565b9250806001600160801b0316886005015f878581518110610b3657610b366130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f2080547affffffffffffffffffffffffffffffffffffffffffffffffffffff92909216650100000000000264ffffffffff90921691909117905550600101610a74565b506001860180547fffffffffffffffffffffffffffffffff00000000000000000000000000000000166001600160801b0392909216919091179055506b033b2e3c9fd0803ce80000009450505b610bf084611a60565b6001840180546001600160801b03928316600160801b02921691909117905584158015610c28575060018301546001600160801b0316155b15610c455760405162839e0f60e81b815260040160405180910390fd5b6040518481527fb4fde7403c001c7cdeafc0c3bb46e972111b7efac4e832398cbf9fabe1694ed99060200160405180910390a150505092915050565b5f516020613abf5f395f51905f525481515f916001600160a01b03169015610d1557610cb289898989898989611a9c565b6040516315a38ec760e11b8152600481018b90523060248201529092506001600160a01b03821690632b471d8e906044015f604051808303815f87803b158015610cfa575f5ffd5b505af1158015610d0c573d5f5f3e3d5ffd5b50505050610d75565b6040516315a38ec760e11b8152600481018a9052336024820181905292506001600160a01b03821690632b471d8e906044015f604051808303815f87803b158015610d5e575f5ffd5b505af1158015610d70573d5f5f3e3d5ffd5b505050505b50979650505050505050565b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c778054604080516020808402820181019092528281525f516020613abf5f395f51905f52935f939192909190830182828015610e0457602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610de6575b505050505090505f5f84608001515190505f5b81811015611199578560c001518181518110610e3557610e356130b1565b602002602001015186608001518281518110610e5357610e536130b1565b60200260200101511015610e93576040517fa1aabbe100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f86608001518281518110610eaa57610eaa6130b1565b6020026020010151118015610ee857505f610ee687606001518381518110610ed457610ed46130b1565b60200260200101518860e00151611bba565b125b15611155575f856005015f868681518110610f0557610f056130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f208054909150640100000000900460ff1615801590610fda5750610fd8816006018054610f52906131fc565b80601f0160208091040260200160405190810160405280929190818152602001828054610f7e906131fc565b8015610fc95780601f10610fa057610100808354040283529160200191610fc9565b820191905f5260205f20905b815481529060010190602001808311610fac57829003601f168201915b50505050508860400151611c16565b155b15611011576040517f584a793800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff16156110f7576110f287606001518381518110611034576110346130b1565b6020026020010151886040015189608001518581518110611057576110576130b1565b6020026020010151846007016001018054611071906131fc565b80601f016020809104026020016040519081016040528092919081815260200182805461109d906131fc565b80156110e85780601f106110bf576101008083540402835291602001916110e8565b820191905f5260205f20905b8154815290600101906020018083116110cb57829003601f168201915b5050505050611d87565b611153565b611153876040015188608001518481518110611115576111156130b1565b602002602001015189606001518581518110611133576111336130b1565b60200260200101516001600160a01b0316611e489092919063ffffffff16565b505b8060018760a00151858151811061116e5761116e6130b1565b602002602001015161118091906130ec565b116111915761118e83613234565b92505b600101610e17565b505050505050565b5f8060608080835f516020613abf5f395f51905f5290505f5f8260020180548060200260200160405190810160405280929190818152602001828054801561121057602002820191905f5260205f20905b81546001600160a01b031681526001909101906020018083116111f2575b505050505090505f815190505f8167ffffffffffffffff81111561123657611236612b99565b60405190808252806020026020018201604052801561125f578160200160208202803683370190505b5095505f5b8281101561133157856005015f858381518110611283576112836130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f9081205460ff1690036112c1576112ba82613234565b915061130b565b856005015f8583815181106112d8576112d86130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f206007015461130890836131ca565b91505b8187828151811061131e5761131e6130b1565b6020908102919091010152600101611264565b508067ffffffffffffffff81111561134b5761134b612b99565b604051908082528060200260200182016040528015611374578160200160208202803683370190505b5096508067ffffffffffffffff81111561139057611390612b99565b6040519080825280602002602001820160405280156113b9578160200160208202803683370190505b5097505f5f5b83811015611774575f876005015f8784815181106113df576113df6130b1565b6020908102919091018101516001600160a01b031682528101919091526040015f908120805490925060ff161561157d5760606114a8836007016001018054611427906131fc565b80601f0160208091040260200160405190810160405280929190818152602001828054611453906131fc565b801561149e5780601f106114755761010080835404028352916020019161149e565b820191905f5260205f20905b81548152906001019060200180831161148157829003601f168201915b5050505050611ecd565b81519093509091505f5b8181101561156957600785018054829081106114d0576114d06130b1565b5f918252602090912001546001600160a01b03168f6114ef838a6131ca565b815181106114ff576114ff6130b1565b60200260200101906001600160a01b031690816001600160a01b031681525050828181518110611531576115316130b1565b60200260200101518e828961154691906131ca565b81518110611556576115566130b1565b60209081029190910101526001016114b2565b5061157481876131ca565b9550505061168b565b86838151811061158f5761158f6130b1565b60209081029190910101516040517f70a082310000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa1580156115f6573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061161a919061324c565b905086838151811061162e5761162e6130b1565b60200260200101518c8581518110611648576116486130b1565b6001600160a01b0390921660209283029190910190910152808b8561166c81613234565b96508151811061167e5761167e6130b1565b6020026020010181815250505b5f61171f83600501805461169e906131fc565b80601f01602080910402602001604051908101604052809291908181526020018280546116ca906131fc565b80156117155780601f106116ec57610100808354040283529160200191611715565b820191905f5260205f20905b8154815290600101906020018083116116f857829003601f168201915b5050505050611f7c565b8354909150670de0b6b3a7640000906117469084906301000000900460ff1660125f612048565b611750908361309a565b61175a91906130d9565b611764908a6131ca565b98505050508060010190506113bf565b50506001808601546117a8916001600160801b0380831692600160801b900416906b033b2e3c9fd0803ce8000000906120c3565b985088156117d0576117c96117c485633b9aca008c60016120c3565b612105565b99506117dc565b67ffffffffffffffff99505b50505050509091929394565b5f5f6117f860018560018861213b565b9050801580156118345750835f81518110611815576118156130b1565b602002602001015167ffffffffffffffff168567ffffffffffffffff16105b1561185b57825f8151811061184b5761184b6130b1565b6020026020010151915050610930565b6001845161186991906130ec565b810361188e57826001855161187e91906130ec565b8151811061184b5761184b6130b1565b8381815181106118a0576118a06130b1565b6020026020010151848260016118b691906131ca565b815181106118c6576118c66130b1565b60200260200101516118d89190613263565b8482815181106118ea576118ea6130b1565b6020026020010151866118fd9190613263565b84838151811061190f5761190f6130b1565b60200260200101518584600161192591906131ca565b81518110611935576119356130b1565b60200260200101516119479190613283565b61195191906132b2565b61195b91906132d1565b83828151811061196d5761196d6130b1565b602002602001015161197f919061330e565b95945050505050565b6040516001600160a01b038085166024830152831660448201527fffffffff00000000000000000000000000000000000000000000000000000000821660648201525f908190819060840160408051601f19818403018152918152602080830180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fb7009613000000000000000000000000000000000000000000000000000000001781525f808052918290528351939450919290918a5afa15611a56575f516020805191945081901c150291505b5094509492505050565b5f6001600160801b03821115611a98576040516306dfcc6560e41b815260806004820152602481018390526044015b60405180910390fd5b5090565b5f5f82806020019051810190611ab2919061338a565b905088816020015114611af1576040517f1115766700000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f611b09825f01518b8b8b8b8b8b89608001516122d0565b5f516020613abf5f395f51905f525483516020850151604080870151606088015160a089015192517f88b7ab630000000000000000000000000000000000000000000000000000000081529697506001600160a01b03909516956388b7ab6395611b7e959430949093928a9190600401613431565b5f604051808303815f87803b158015611b95575f5ffd5b505af1158015611ba7573d5f5f3e3d5ffd5b505092519b9a5050505050505050505050565b80515f90815b81811015611c0b57838181518110611bda57611bda6130b1565b60200260200101516001600160a01b0316856001600160a01b031603611c035791506102359050565b600101611bc0565b505f19949350505050565b5f5f5f84806020019051810190611c2d91906134b1565b915091505f611c465f516020613abf5f395f51905f5290565b6008015f848015611c5957611c596134ff565b8015611c6757611c676134ff565b81526020019081526020015f205f866001600160a01b03166001600160a01b031681526020019081526020015f20541115611ca757600192505050610235565b805115611d7d575f828015611cbe57611cbe6134ff565b03611d7d575f81806020019051810190611cd89190613513565b90506001600160a01b03811615611d7b576040517f65e4ad9e0000000000000000000000000000000000000000000000000000000081523060048201526001600160a01b0386811660248301528216906365e4ad9e906044016020604051808303815f875af1158015611d4d573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611d71919061352e565b9350505050610235565b505b505f949350505050565b5f5f611d92836123b7565b90925090505f828015611da757611da76134ff565b036111995780806020019051810190611dc09190613513565b6040517f8bfb07c90000000000000000000000000000000000000000000000000000000081526001600160a01b0388811660048301528781166024830152604482018790529190911690638bfb07c9906064015f604051808303815f87803b158015611e2a575f5ffd5b505af1158015611e3c573d5f5f3e3d5ffd5b50505050505050505050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052611ec89084906123d8565b505050565b60605f5f5f611edb856123b7565b90925090505f828015611ef057611ef06134ff565b03611f755780806020019051810190611f099190613513565b6001600160a01b03166301e1d1146040518163ffffffff1660e01b81526004015f60405180830381865afa158015611f43573d5f5f3e3d5ffd5b505050506040513d5f823e601f3d908101601f19168201604052611f6a9190810190613549565b935093505050915091565b5050915091565b5f5f5f5f5f611f8a86612463565b50929650909450925090506001846009811115611fa957611fa96134ff565b03612030575f82806020019051810190611fc39190613513565b9050806001600160a01b0316636256f2c56040518163ffffffff1660e01b8152600401602060405180830381865afa158015612001573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612025919061324c565b979650505050505050565b61203d848484845f612490565b509695505050505050565b5f8260ff168460ff161115612084575f61206284866135e4565b61206d90600a6136e0565b905061207c86600183866120c3565b9150506120bb565b8260ff168460ff1610156120b85761209c84846135e4565b6120a790600a6136e0565b6120b1908661309a565b90506120bb565b50835b949350505050565b5f6120f06120d08361252b565b80156120eb57505f84806120e6576120e66130c5565b868809115b151590565b6120fb868686612557565b61197f91906131ca565b5f67ffffffffffffffff821115611a9857604080516306dfcc6560e41b8152600481019190915260248101839052604401611a8f565b5f83515f0361214b57505f6120bb565b835160019086801561219f575067ffffffffffffffff841685876121706001856130ec565b81518110612180576121806130b1565b602002602001015161219291906136ee565b67ffffffffffffffff1611155b806121f55750861580156121f5575067ffffffffffffffff841685876121c66001856130ec565b815181106121d6576121d66130b1565b60200260200101516121e891906136ee565b67ffffffffffffffff1610155b1561220e576122056001826130ec565b925050506120bb565b808210156122c5575f6122218383612607565b905087612268578467ffffffffffffffff1686888381518110612246576122466130b1565b602002602001015161225891906136ee565b67ffffffffffffffff16106122a4565b8467ffffffffffffffff1686888381518110612286576122866130b1565b602002602001015161229891906136ee565b67ffffffffffffffff16115b156122b1578091506122bf565b6122bc8160016131ca565b92505b5061220e565b6120256001836130ec565b5f7fb6577f08e668b53303325a19233e8315142d69bedb6d7e1d8d0e9af2473486d45f1b89898989896040516020016123099190613711565b6040516020818303038152906040528051906020012089604051602001612330919061300a565b60408051808303601f190181528282528051602091820120818401999099526001600160a01b0397881683830152606083019690965293909516608086015260a085019190915260c084015260e083019390935261010082019590955261012080820194909452815180820390940184526101400190525080519101209695505050505050565b5f6060828060200190518101906123ce91906134b1565b9094909350915050565b5f5f60205f8451602086015f885af1806123f7576040513d5f823e3d81fd5b50505f513d9150811561240e57806001141561241b565b6001600160a01b0384163b155b1561245d576040517f5274afe70000000000000000000000000000000000000000000000000000000081526001600160a01b0385166004820152602401611a8f565b50505050565b5f5f60608060608580602001905181019061247e919061374e565b939a9299509097509550909350915050565b5f5f6124a586670de0b6b3a764000086612621565b90506124b2878287612621565b91506124c6670de0b6b3a76400008361309a565b6124d884670de0b6b3a76400006130ec565b6124e2908361309a565b10801561251a57506124fc83670de0b6b3a76400006131ca565b612506908261309a565b612518670de0b6b3a76400008461309a565b105b1561016a5796879650945050505050565b5f6002826003811115612540576125406134ff565b61254a91906137fd565b60ff166001149050919050565b5f5f5f6125648686612a1f565b91509150815f036125885783818161257e5761257e6130c5565b0492505050610930565b81841161259f5761259f6003851502601118612a3b565b5f848688095f868103871696879004966002600389028118808a02820302808a02820302808a02820302808a02820302808a02820302808a02909103029181900381900460010185841190960395909502919093039390930492909217029150509392505050565b5f61261560028484186130d9565b610232908484166131ca565b5f80846009811115612635576126356134ff565b03612705575f5f5f5f5f868060200190518101906126539190613901565b945094509450945094505f612668828a612a4c565b86519091505f5b818110156126f5576126eb8389838151811061268d5761268d6130b1565b60200260200101518884815181106126a7576126a76130b1565b60200260200101518885815181106126c1576126c16130b1565b602002602001015160ff168b86815181106126de576126de6130b1565b6020026020010151612a7b565b925060010161266f565b5081975050505050505050610930565b6003846009811115612719576127196134ff565b0361272d5750670de0b6b3a7640000610930565b6002846009811115612741576127416134ff565b0361274d575081610930565b6004846009811115612761576127616134ff565b036127ff576040517f7a28fb88000000000000000000000000000000000000000000000000000000008152670de0b6b3a7640000600482015273ae7ab96520de3a18e5e111b5eaab095312d7fe8490637a28fb8890602401602060405180830381865afa1580156127d4573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906127f8919061324c565b9050610930565b6005846009811115612813576128136134ff565b036128685773be9895146f7af43049ca1c1ae358b0541ea497046001600160a01b0316633ba0b9a96040518163ffffffff1660e01b8152600401602060405180830381865afa1580156127d4573d5f5f3e3d5ffd5b600684600981111561287c5761287c6134ff565b036128d15773ae78736cd615f374d3085123a210448e74fc63936001600160a01b031663e6aa216c6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156127d4573d5f5f3e3d5ffd5b60078460098111156128e5576128e56134ff565b0361293a5773ac3e018457b222d93114458476f3e3416abbe38f6001600160a01b03166399530b066040518163ffffffff1660e01b8152600401602060405180830381865afa1580156127d4573d5f5f3e3d5ffd5b600884600981111561294e5761294e6134ff565b03612971575f82806020019051810190612968919061324c565b91506109309050565b6009846009811115612985576129856134ff565b03612a18575f5f838060200190518101906129a09190613a2c565b9150915080826001600160a01b031663a035b1fe6040518163ffffffff1660e01b8152600401602060405180830381865afa1580156129e1573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612a05919061324c565b612a0f91906130d9565b92505050610930565b5081610930565b5f805f1983850993909202808410938190039390930393915050565b634e487b715f52806020526024601cfd5b5f80836001811115612a6057612a606134ff565b03612a745750670de0b6b3a7640000610235565b5080610235565b5f5f5f866001600160a01b031663feaf968c6040518163ffffffff1660e01b815260040160a060405180830381865afa158015612aba573d5f5f3e3d5ffd5b505050506040513d601f19601f82011682018060405250810190612ade9190613a71565b509350509250505f82131580612b02575063ffffffff8416612b0082426130ec565b115b15612b39576040517fae19356300000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b8560ff16600103612b6c57612b4f85600a613ab3565b612b59838a61309a565b612b6391906130d9565b9250505061197f565b81612b7886600a613ab3565b612b59908a61309a565b6001600160a01b0381168114612b96575f5ffd5b50565b634e487b7160e01b5f52604160045260245ffd5b60405160c0810167ffffffffffffffff81118282101715612bd057612bd0612b99565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715612bff57612bff612b99565b604052919050565b5f67ffffffffffffffff821115612c2057612c20612b99565b5060051b60200190565b5f82601f830112612c39575f5ffd5b8135612c4c612c4782612c07565b612bd6565b8082825260208201915060208360051b860101925085831115612c6d575f5ffd5b602085015b83811015612c8a578035835260209283019201612c72565b5095945050505050565b5f82601f830112612ca3575f5ffd5b8135612cb1612c4782612c07565b8082825260208201915060208360051b860101925085831115612cd2575f5ffd5b602085015b83811015612c8a578035612cea81612b82565b835260209283019201612cd7565b5f5f5f5f5f5f60c08789031215612d0d575f5ffd5b863595506020870135612d1f81612b82565b945060408701359350606087013567ffffffffffffffff811115612d41575f5ffd5b612d4d89828a01612c2a565b935050608087013567ffffffffffffffff811115612d69575f5ffd5b612d7589828a01612c94565b9699959850939692959460a09093013593505050565b5f8151808452602084019350602083015f5b82811015612dc45781516001600160a01b0316865260209586019590910190600101612d9d565b5093949350505050565b5f8151808452602084019350602083015f5b82811015612dc4578151865260209586019590910190600101612de0565b604081525f612e106040830185612d8b565b828103602084015261197f8185612dce565b5f5f5f5f5f60a08688031215612e36575f5ffd5b853594506020860135612e4881612b82565b935060408601359250606086013567ffffffffffffffff811115612e6a575f5ffd5b612e7688828901612c2a565b95989497509295608001359392505050565b5f60208284031215612e98575f5ffd5b5035919050565b5f67ffffffffffffffff821115612eb857612eb8612b99565b50601f01601f191660200190565b5f82601f830112612ed5575f5ffd5b8135612ee3612c4782612e9f565b818152846020838601011115612ef7575f5ffd5b816020850160208301375f918101602001919091529392505050565b5f5f5f5f5f5f5f60e0888a031215612f29575f5ffd5b873596506020880135612f3b81612b82565b955060408801359450606088013567ffffffffffffffff811115612f5d575f5ffd5b612f698a828b01612c2a565b945050608088013567ffffffffffffffff811115612f85575f5ffd5b612f918a828b01612c94565b93505060a0880135915060c088013567ffffffffffffffff811115612fb4575f5ffd5b612fc08a828b01612ec6565b91505092959891949750929550565b8015158114612b96575f5ffd5b5f5f60408385031215612fed575f5ffd5b823591506020830135612fff81612fcf565b809150509250929050565b81515f90829060208501835b8281101561303d5781516001600160a01b0316845260209384019390910190600101613016565b509195945050505050565b848152608060208201525f6130606080830186612d8b565b82810360408401526130728186612dce565b905082810360608401526120258185612d8b565b634e487b7160e01b5f52601160045260245ffd5b808202811582820484141761023557610235613086565b634e487b7160e01b5f52603260045260245ffd5b634e487b7160e01b5f52601260045260245ffd5b5f826130e7576130e76130c5565b500490565b8181038181111561023557610235613086565b5f5f8585111561310d575f5ffd5b83861115613119575f5ffd5b5050820193919092039150565b80357fffffffff000000000000000000000000000000000000000000000000000000008116906004841015613185577fffffffff00000000000000000000000000000000000000000000000000000000808560040360031b1b82161691505b5092915050565b6001600160a01b038416815260406020820152816040820152818360608301375f818301606090810191909152601f909201601f1916010192915050565b8082018082111561023557610235613086565b6001600160801b03818116838216019081111561023557610235613086565b600181811c9082168061321057607f821691505b60208210810361322e57634e487b7160e01b5f52602260045260245ffd5b50919050565b5f6001820161324557613245613086565b5060010190565b5f6020828403121561325c575f5ffd5b5051919050565b67ffffffffffffffff828116828216039081111561023557610235613086565b600782810b9082900b03677fffffffffffffff198112677fffffffffffffff8213171561023557610235613086565b5f8260070b8260070b028060070b915080821461318557613185613086565b5f8160070b8360070b806132e7576132e76130c5565b677fffffffffffffff1982145f198214161561330557613305613086565b90059392505050565b600781810b9083900b01677fffffffffffffff8113677fffffffffffffff198212171561023557610235613086565b5f82601f83011261334c575f5ffd5b815161335a612c4782612e9f565b81815284602083860101111561336e575f5ffd5b8160208501602083015e5f918101602001919091529392505050565b5f6020828403121561339a575f5ffd5b815167ffffffffffffffff8111156133b0575f5ffd5b820160c081850312156133c1575f5ffd5b6133c9612bad565b81516133d481612b82565b81526020828101519082015260408083015190820152606080830151908201526080808301519082015260a082015167ffffffffffffffff811115613417575f5ffd5b6134238682850161333d565b60a083015250949350505050565b6001600160a01b03881681526001600160a01b03871660208201528560408201528460608201528360808201528260a082015260e060c08201525f82518060e0840152806020850161010085015e5f6101008285010152610100601f19601f83011684010191505098975050505050505050565b60018110612b96575f5ffd5b5f5f604083850312156134c2575f5ffd5b82516134cd816134a5565b602084015190925067ffffffffffffffff8111156134e9575f5ffd5b6134f58582860161333d565b9150509250929050565b634e487b7160e01b5f52602160045260245ffd5b5f60208284031215613523575f5ffd5b815161093081612b82565b5f6020828403121561353e575f5ffd5b815161093081612fcf565b5f5f6040838503121561355a575f5ffd5b825167ffffffffffffffff811115613570575f5ffd5b8301601f81018513613580575f5ffd5b805161358e612c4782612c07565b8082825260208201915060208360051b8501019250878311156135af575f5ffd5b6020840193505b828410156135d15783518252602093840193909101906135b6565b6020969096015195979596505050505050565b60ff828116828216039081111561023557610235613086565b6001815b60018411156136385780850481111561361c5761361c613086565b600184161561362a57908102905b60019390931c928002613601565b935093915050565b5f8261364e57506001610235565b8161365a57505f610235565b8160018114613670576002811461367a57613696565b6001915050610235565b60ff84111561368b5761368b613086565b50506001821b610235565b5060208310610133831016604e8410600b84101617156136b9575081810a610235565b6136c55f1984846135fd565b805f19048211156136d8576136d8613086565b029392505050565b5f61023260ff841683613640565b67ffffffffffffffff818116838216029081169081811461318557613185613086565b81515f90829060208501835b8281101561303d57815184526020938401939091019060010161371d565b8051600a8110613749575f5ffd5b919050565b5f5f5f5f5f60a08688031215613762575f5ffd5b61376b8661373b565b94506137796020870161373b565b9350604086015167ffffffffffffffff811115613794575f5ffd5b6137a08882890161333d565b935050606086015167ffffffffffffffff8111156137bc575f5ffd5b6137c88882890161333d565b925050608086015167ffffffffffffffff8111156137e4575f5ffd5b6137f08882890161333d565b9150509295509295909350565b5f60ff83168061380f5761380f6130c5565b8060ff84160691505092915050565b5f82601f83011261382d575f5ffd5b815161383b612c4782612c07565b8082825260208201915060208360051b86010192508583111561385c575f5ffd5b602085015b83811015612c8a57805163ffffffff8116811461387c575f5ffd5b835260209283019201613861565b5f82601f830112613899575f5ffd5b81516138a7612c4782612c07565b8082825260208201915060208360051b8601019250858311156138c8575f5ffd5b602085015b83811015612c8a57805160ff811681146138e5575f5ffd5b8352602092830192016138cd565b805160028110613749575f5ffd5b5f5f5f5f5f60a08688031215613915575f5ffd5b855167ffffffffffffffff81111561392b575f5ffd5b8601601f8101881361393b575f5ffd5b8051613949612c4782612c07565b8082825260208201915060208360051b85010192508a83111561396a575f5ffd5b6020840193505b8284101561399557835161398481612b82565b825260209384019390910190613971565b80985050505050602086015167ffffffffffffffff8111156139b5575f5ffd5b6139c18882890161381e565b945050604086015167ffffffffffffffff8111156139dd575f5ffd5b6139e98882890161388a565b935050606086015167ffffffffffffffff811115613a05575f5ffd5b613a118882890161388a565b925050613a20608087016138f3565b90509295509295909350565b5f5f60408385031215613a3d575f5ffd5b8251613a4881612b82565b6020939093015192949293505050565b805169ffffffffffffffffffff81168114613749575f5ffd5b5f5f5f5f5f60a08688031215613a85575f5ffd5b613a8e86613a58565b60208701516040880151606089015192975090955093509150613a2060808701613a58565b5f610232838361364056fe4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75a2646970667358221220b7fbf7d6a933c486c1d974bb6f124b67553467f098ad407daa4edc583ab3f08764736f6c634300081c0033",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -347,10 +367,11 @@
           "tokens": "List of tokens that would be given"
         }
       },
-      "redeem(uint256,address,uint256,uint256[])": {
+      "redeem(uint256,address,uint256,uint256[],bytes32)": {
         "details": "The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function",
         "params": {
           "deadline": "Timestamp before which the redemption should have occured",
+          "expectedTokensHash": "`keccak256(abi.encodePacked(tokens))` over the output list the caller was quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since `minAmountOuts` is positional and a collateral rotation can change which token each entry protects",
           "minAmountOuts": "Minimum amount of each token given back in the redemption to obtain",
           "receiver": "Address which should be receiving the output tokens"
         },
@@ -359,10 +380,10 @@
           "tokens": "List of tokens returned"
         }
       },
-      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": {
-        "details": "The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`."
+      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": {
+        "details": "The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.`expectedTokensHash` matters most here: a signature stays executable for its whole validity window, so without it a relayer could hold one until a collateral rotation reshuffles the output list"
       },
-      "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": {
+      "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": {
         "details": "Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount"
       },
       "updateNormalizer(uint256,bool)": {
@@ -375,28 +396,28 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "2988000",
-        "executionCost": "3276",
-        "totalCost": "2991276"
+        "codeDepositCost": "3024800",
+        "executionCost": "3323",
+        "totalCost": "3028123"
       },
       "external": {
         "quoteRedemptionCurve(uint256)": "infinite",
-        "redeem(uint256,address,uint256,uint256[])": "infinite",
-        "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": "infinite",
-        "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": "infinite",
+        "redeem(uint256,address,uint256,uint256[],bytes32)": "infinite",
+        "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": "infinite",
+        "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": "infinite",
         "updateNormalizer(uint256,bool)": "infinite"
       },
       "internal": {
-        "_consumeAuthAndBurn(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_consumeAuthAndBurn(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_distributeRedemption(struct Redeemer.RedemptionExecution memory)": "infinite",
-        "_executeAuthorization(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_executeAuthorization(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_quoteRedemptionCurve(uint256)": "infinite",
-        "_redeem(uint256,address,uint256,uint256[] memory,address[] memory,bytes memory)": "infinite",
+        "_redeem(uint256,address,uint256,uint256[] memory,address[] memory,bytes32,bytes memory)": "infinite",
         "_updateNormalizer(uint256,bool)": "infinite"
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"CannotBurnAllStableIssued\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotWhitelisted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNormalizerValue\",\"type\":\"uint256\"}],\"name\":\"NormalizerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Redeemed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"quoteRedemptionCurve\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"}],\"name\":\"redeem\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"authData\",\"type\":\"bytes\"}],\"name\":\"redeemWithAuthorization\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"}],\"name\":\"redeemWithForfeit\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"updateNormalizer\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `Redeemer` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"returns\":{\"amounts\":\"Amount that would be obtained for each token in the `tokens` array\",\"tokens\":\"List of tokens that would be given\"}},\"redeem(uint256,address,uint256,uint256[])\":{\"details\":\"The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function\",\"params\":{\"deadline\":\"Timestamp before which the redemption should have occured\",\"minAmountOuts\":\"Minimum amount of each token given back in the redemption to obtain\",\"receiver\":\"Address which should be receiving the output tokens\"},\"returns\":{\"amounts\":\"Amount given for each token in the `tokens` array\",\"tokens\":\"List of tokens returned\"}},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)\":{\"details\":\"The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[])\":{\"details\":\"Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount\"},\"updateNormalizer(uint256,bool)\":{\"details\":\"This function may be called by trusted addresses: these could be for instance savings contract minting stablecoins when they notice a profit\"}},\"title\":\"Redeemer\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"notice\":\"Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\"},\"redeem(uint256,address,uint256,uint256[])\":{\"notice\":\"Redeems `amount` of stablecoins from the system\"},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)\":{\"notice\":\"Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[])\":{\"notice\":\"Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`.\"},\"updateNormalizer(uint256,bool)\":{\"notice\":\"Updates the normalizer variable by `amount`\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Redeemer.sol\":\"Redeemer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts` or `forfeitTokens` invalidates the\\n  /// signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x2ea4d5ebd3dd0e83071ebedb2c269f501f37033ddce9a1ee9ec40cfde0adfc7a\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IEIP3009.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IEIP3009\\n/// @notice Interface for EIP-3009: Transfer With Authorization\\ninterface IEIP3009 {\\n  /// @notice Execute a transfer with a signed authorization (EOA signature)\\n  /// @dev SECURITY: anyone may submit this call (no `msg.sender` restriction). Integrators that\\n  /// pair the transfer with downstream logic (e.g. swap, deposit, redeem) MUST use\\n  /// `receiveWithAuthorization` instead: a mempool watcher can otherwise frontrun the original\\n  /// transaction with a raw `transferWithAuthorization`, burning the nonce so the original\\n  /// reverts while the funds still move - causing the post-transfer logic to be skipped.\\n  /// Use this primitive only for direct payouts to a passive recipient (`msg.sender != to`).\\n  /// @param from The address of the sender\\n  /// @param to The address of the recipient\\n  /// @param value The amount of tokens to transfer\\n  /// @param validAfter The timestamp after which the authorization is valid\\n  /// @param validBefore The timestamp before which the authorization is valid\\n  /// @param nonce The nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Execute a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev SECURITY: see the EOA overload - this primitive is frontrun-prone and must not be used\\n  /// when the transfer is bound to follow-on logic. Use `receiveWithAuthorization` in that case.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EOA signature)\\n  /// @dev The caller must be the payee (`to` address). This has an additional check to ensure\\n  /// that the payee's address matches the caller of this function to prevent front-running attacks.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev The caller must be the payee (`to` address)\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Attempt to cancel an authorization\\n  /// @dev Works only if the authorization is not yet used.\\n  /// EOA wallet signatures should be packed in the order of r, s, v.\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external;\\n\\n  /// @notice Cancel an authorization (EIP-1271 compatible)\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external;\\n\\n  /// @notice Returns the state of an authorization\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @return true if the nonce is used\\n  function authorizationState(address authorizer, bytes32 nonce) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe34cfb584a925054c2e3569c4401c619cd2b928a7b9da04537e71a9089edf55a\",\"license\":\"MIT\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Redeemer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IRedeemer } from \\\"contracts/interfaces/IRedeemer.sol\\\";\\nimport { IEIP3009 } from \\\"contracts/interfaces/external/IEIP3009.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\nimport { LibAuthorization } from \\\"../libraries/LibAuthorization.sol\\\";\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Redeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `Redeemer` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\\ncontract Redeemer is IRedeemer, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  event Redeemed(\\n    uint256 amount,\\n    address[] tokens,\\n    uint256[] amounts,\\n    address[] forfeitTokens,\\n    address indexed from,\\n    address indexed to\\n  );\\n  event NormalizerUpdated(uint256 newNormalizerValue);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev The `minAmountOuts` list must reflect the amount of `tokens` returned\\n  /// @dev In normal conditions, the amount of tokens outputted by this function should be the amount\\n  /// of collateral assets supported by the system, following their order in the `collateralList`.\\n  /// @dev If one collateral has its liquidity managed through strategies, then it's possible that this asset\\n  /// has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption\\n  /// process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral\\n  /// assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering\\n  /// of the token list will be as follows:\\n  /// `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`\\n  /// @dev The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained\\n  /// by calling the `quoteRedemptionCurve` function\\n  /// @dev Tokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the\\n  /// whitelist, otherwise this function reverts\\n  /// @dev No approval is needed before calling this function\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token\\n  /// even if it has enough immediately available to send the amount\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, authData);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev This function may be called by trusted addresses: these could be for instance savings contract\\n  /// minting stablecoins when they notice a profit\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256) {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && s.transmuterStorage().isTrusted[msg.sender] == 0) {\\n      revert NotTrusted();\\n    }\\n    return _updateNormalizer(amount, increase);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    (tokens, amounts,) = _quoteRedemptionCurve(amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Working set passed by reference between `_redeem` and its loop helper, so the call\\n  /// site stays under the EVM stack-depth limit when compiling without via-IR.\\n  struct RedemptionExecution {\\n    uint256 amount;\\n    address from;\\n    address to;\\n    address[] tokens;\\n    uint256[] amounts;\\n    uint256[] subCollateralsTracker;\\n    uint256[] minAmountOuts;\\n    address[] forfeitTokens;\\n  }\\n\\n  /// @notice Internal function of the `redeem` function in the `Redeemer` contract\\n  function _redeem(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    nonReentrant\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    if (s.transmuterStorage().isRedemptionLive == 0) revert Paused();\\n    if (block.timestamp > deadline) revert TooLate();\\n\\n    RedemptionExecution memory redemption;\\n    redemption.amount = amount;\\n    redemption.to = to;\\n    redemption.minAmountOuts = minAmountOuts;\\n    redemption.forfeitTokens = forfeitTokens;\\n\\n    (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);\\n    if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();\\n    _updateNormalizer(amount, false);\\n\\n    redemption.from = _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, authData);\\n\\n    _distributeRedemption(redemption);\\n    emit Redeemed(\\n      redemption.amount,\\n      redemption.tokens,\\n      redemption.amounts,\\n      redemption.forfeitTokens,\\n      redemption.from,\\n      redemption.to\\n    );\\n    return (redemption.tokens, redemption.amounts);\\n  }\\n\\n  /// @notice Releases each non-forfeited collateral output to `redemption.to`. Extracted from `_redeem`\\n  /// so the parent function stays within the EVM stack-depth limit.\\n  function _distributeRedemption(RedemptionExecution memory redemption) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 indexCollateral;\\n    uint256 amountsLength = redemption.amounts.length;\\n    for (uint256 i; i < amountsLength; ++i) {\\n      if (redemption.amounts[i] < redemption.minAmountOuts[i]) revert TooSmallAmountOut();\\n      // If a token is in the `forfeitTokens` list, then it is not sent as part of the redemption process\\n      if (redemption.amounts[i] > 0 && LibHelpers.checkList(redemption.tokens[i], redemption.forfeitTokens) < 0) {\\n        Collateral storage collatInfo = ts.collaterals[collateralListMem[indexCollateral]];\\n        if (collatInfo.onlyWhitelisted > 0 && !LibWhitelist.checkWhitelist(collatInfo.whitelistData, redemption.to)) {\\n          revert NotWhitelisted();\\n        }\\n        if (collatInfo.isManaged > 0) {\\n          LibManager.release(\\n            redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config\\n          );\\n        } else {\\n          IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);\\n        }\\n      }\\n      if (redemption.subCollateralsTracker[indexCollateral] - 1 <= i) ++indexCollateral;\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer (auth flow) or burns directly from\\n  /// `msg.sender`, and returns the address to attribute the `Redeemed` event to.\\n  function _consumeAuthAndBurn(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    ITokenP tokenP = s.transmuterStorage().tokenP;\\n    if (authData.length > 0) {\\n      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, authData);\\n      tokenP.burnSelf(amount, address(this));\\n    } else {\\n      from = msg.sender;\\n      tokenP.burnSelf(amount, msg.sender);\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer via EIP-3009 `receiveWithAuthorization`,\\n  /// using a derived nonce that binds the full redemption intent.\\n  /// @return from The authorizer address (`params.from`), to attribute the redeem event to\\n  function _executeAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));\\n    if (params.value != amount) revert InvalidSwap();\\n    bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(\\n      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, params.nonce\\n    );\\n    IEIP3009(address(s.transmuterStorage().tokenP)).receiveWithAuthorization(\\n      params.from,\\n      address(this),\\n      params.value,\\n      params.validAfter,\\n      params.validBefore,\\n      derivedNonce,\\n      params.signature\\n    );\\n    return params.from;\\n  }\\n\\n  /// @dev This function reverts if `stablecoinsIssued==0`, which is expected behavior as there is nothing to redeem\\n  /// anyway in this case, or if the `amountBurnt` is greater than `stablecoinsIssued`\\n  /// @dev Invariant: `penaltyFactor` is evaluated once at the entry-time `collatRatio` and applied uniformly to the\\n  /// full `amountBurnt`. The curve is not path-integrated, so a single redemption that traverses into a lower-penalty\\n  /// segment still pays the entry-time rate on every unit burned. Splitting the same redemption into smaller calls\\n  /// can yield a strictly better blended rate when the path crosses an ascending segment of the curve. This is a\\n  /// deliberate design choice consistent with penalizing early redemptions during under-collateralization; the gap\\n  /// between single-call and path-integrated pricing scales with the ascending-segment slope and should be\\n  /// considered when calibrating `xRedemptionCurve`/`yRedemptionCurve`.\\n  function _quoteRedemptionCurve(uint256 amountBurnt)\\n    internal\\n    view\\n    returns (address[] memory tokens, uint256[] memory balances, uint256[] memory subCollateralsTracker)\\n  {\\n    uint64 collatRatio;\\n    uint256 stablecoinsIssued;\\n    (collatRatio, stablecoinsIssued, tokens, balances, subCollateralsTracker) = LibGetters.getCollateralRatio();\\n    if (amountBurnt >= stablecoinsIssued) revert CannotBurnAllStableIssued();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    int64[] memory yRedemptionCurveMem = ts.yRedemptionCurve;\\n    uint64 penaltyFactor;\\n    // If the protocol is under-collateralized, a penalty factor is applied to the returned amount of each asset\\n    if (collatRatio < BASE_9) {\\n      uint64[] memory xRedemptionCurveMem = ts.xRedemptionCurve;\\n      penaltyFactor = uint64(LibHelpers.piecewiseLinear(collatRatio, xRedemptionCurveMem, yRedemptionCurveMem));\\n    }\\n\\n    for (uint256 i; i < balances.length; ++i) {\\n      // The amount given for each token in reserves does not depend on the price of the tokens in reserve:\\n      // it is a proportion of the balance for each token computed as the ratio between the stablecoins\\n      // burnt relative to the amount of stablecoins issued.\\n      // If the protocol is over-collateralized, the amount of each token given is inversely proportional\\n      // to the collateral ratio.\\n      balances[i] = collatRatio >= BASE_9\\n        ? (amountBurnt * balances[i] * (uint64(yRedemptionCurveMem[yRedemptionCurveMem.length - 1])))\\n          / (stablecoinsIssued * collatRatio)\\n        : (amountBurnt * balances[i] * penaltyFactor) / (stablecoinsIssued * BASE_9);\\n    }\\n  }\\n\\n  /// @notice Updates the `normalizer` variable used to track stablecoins issued from each asset and globally\\n  function _updateNormalizer(uint256 amount, bool increase) internal returns (uint256 newNormalizerValue) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    uint256 _normalizedStables = ts.normalizedStables;\\n    // In case of an increase, the update formula used is the simplified version of the formula below:\\n    /*\\n            _normalizer * (BASE_27 + BASE_27 * amount / stablecoinsIssued) / BASE_27\\n        = _normalizer + (_normalizer * BASE_27 * amount * (BASE_27 / (_normalizedStables * normalizer))) / BASE_27\\n             = _normalizer + BASE_27 * amount / _normalizedStables\\n        */\\n    if (increase) {\\n      newNormalizerValue = _normalizer + (amount * BASE_27) / _normalizedStables;\\n    } else {\\n      newNormalizerValue = _normalizer - (amount * BASE_27) / _normalizedStables;\\n    }\\n    // If the `normalizer` gets too small or too big, it must be renormalized to later avoid the propagation of\\n    // rounding errors, as well as overflows. In this case, the function has to iterate through all the\\n    // supported collateral assets\\n    if (newNormalizerValue <= BASE_18 || newNormalizerValue >= BASE_36) {\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 collateralListLength = collateralListMem.length;\\n      // For each asset, we store the actual amount of stablecoins issued based on the `newNormalizerValue`\\n      // (and not a normalized value)\\n      // We ensure to preserve the invariant `sum(collateralNewNormalizedStables) = normalizedStables`\\n      uint128 newNormalizedStables;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        uint128 newCollateralNormalizedStable = ((uint256(ts.collaterals[collateralListMem[i]].normalizedStables)\\n              * newNormalizerValue) / BASE_27)\\n        .toUint128();\\n        newNormalizedStables += newCollateralNormalizedStable;\\n        ts.collaterals[collateralListMem[i]].normalizedStables = uint216(newCollateralNormalizedStable);\\n      }\\n      ts.normalizedStables = newNormalizedStables;\\n      newNormalizerValue = BASE_27;\\n    }\\n    ts.normalizer = newNormalizerValue.toUint128();\\n    if (!increase && ts.normalizedStables == 0) revert CannotBurnAllStableIssued();\\n    emit NormalizerUpdated(newNormalizerValue);\\n  }\\n}\\n\",\"keccak256\":\"0x52467df54a2a68910287c51c0ee42d304de44a7ccacd22fff8426911835356f3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibAuthorization.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\n/// @title LibAuthorization\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Derives the EIP-3009 nonce that binds the Parallelizer's `*WithAuthorization` entry\\n/// points to their full swap/redeem intent (output `to`, slippage, deadline, ...), closing the\\n/// front-running gap left by vanilla `receiveWithAuthorization` which only commits to the token\\n/// transfer itself.\\n/// @dev Off-chain, the authorizer signs a standard EIP-3009 `ReceiveWithAuthorization` with\\n/// `nonce = compute*Nonce(...)`. The facet recomputes the same value from the call arguments and\\n/// forwards it to the token; tampering with any bound field makes the signature invalid. Replay\\n/// protection is provided by the token's own `authorizationStates` mapping; retries use a fresh\\n/// `userSalt`.\\nlibrary LibAuthorization {\\n  // keccak256(\\\"SwapExactInputWithAuthorization(address from,address tokenIn,address tokenOut,uint256 amountIn,uint256\\n  // amountOutMin,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x9be969f74c66b263054aa69cfac8412777a0dc17ab007f81682c6b156ba06d79;\\n\\n  // keccak256(\\\"SwapExactOutputWithAuthorization(address from,address tokenIn,address tokenOut,uint256\\n  // amountOut,uint256 amountInMax,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;\\n\\n  // keccak256(\\\"RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32\\n  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 userSalt)\\\")\\n  bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =\\n    0xcff34e096e1842f6f6ae4c0d0c6eefd4855c8bdc5bc64155d7c14b2dbeee661a;\\n\\n  function computeSwapExactInputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountIn,\\n        amountOutMin,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeSwapExactOutputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountOut,\\n        amountInMax,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeRedeemNonce(\\n    address from,\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        REDEEM_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        amount,\\n        receiver,\\n        deadline,\\n        keccak256(abi.encodePacked(minAmountOuts)),\\n        keccak256(abi.encodePacked(forfeitTokens)),\\n        userSalt\\n      )\\n    );\\n  }\\n}\\n\",\"keccak256\":\"0xe41991a0a564f4f6443aeffd6f1519ae3decc8a9e1e625f51ddf2168453ea4f2\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"CannotBurnAllStableIssued\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotWhitelisted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Paused\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooLate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UnexpectedRedemptionTokens\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newNormalizerValue\",\"type\":\"uint256\"}],\"name\":\"NormalizerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"Redeemed\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"quoteRedemptionCurve\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"}],\"name\":\"redeem\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"authData\",\"type\":\"bytes\"}],\"name\":\"redeemWithAuthorization\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"receiver\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256[]\",\"name\":\"minAmountOuts\",\"type\":\"uint256[]\"},{\"internalType\":\"address[]\",\"name\":\"forfeitTokens\",\"type\":\"address[]\"},{\"internalType\":\"bytes32\",\"name\":\"expectedTokensHash\",\"type\":\"bytes32\"}],\"name\":\"redeemWithForfeit\",\"outputs\":[{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"updateNormalizer\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `Redeemer` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"returns\":{\"amounts\":\"Amount that would be obtained for each token in the `tokens` array\",\"tokens\":\"List of tokens that would be given\"}},\"redeem(uint256,address,uint256,uint256[],bytes32)\":{\"details\":\"The `minAmountOuts` list must reflect the amount of `tokens` returnedIn normal conditions, the amount of tokens outputted by this function should be the amount of collateral assets supported by the system, following their order in the `collateralList`.If one collateral has its liquidity managed through strategies, then it's possible that this asset has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering of the token list will be as follows: `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained by calling the `quoteRedemptionCurve` functionTokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the whitelist, otherwise this function revertsNo approval is needed before calling this function\",\"params\":{\"deadline\":\"Timestamp before which the redemption should have occured\",\"expectedTokensHash\":\"`keccak256(abi.encodePacked(tokens))` over the output list the caller was quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\",\"minAmountOuts\":\"Minimum amount of each token given back in the redemption to obtain\",\"receiver\":\"Address which should be receiving the output tokens\"},\"returns\":{\"amounts\":\"Amount given for each token in the `tokens` array\",\"tokens\":\"List of tokens returned\"}},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)\":{\"details\":\"The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash` invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.`expectedTokensHash` matters most here: a signature stays executable for its whole validity window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)\":{\"details\":\"Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token even if it has enough immediately available to send the amount\"},\"updateNormalizer(uint256,bool)\":{\"details\":\"This function may be called by trusted addresses: these could be for instance savings contract minting stablecoins when they notice a profit\"}},\"title\":\"Redeemer\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"quoteRedemptionCurve(uint256)\":{\"notice\":\"Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\"},\"redeem(uint256,address,uint256,uint256[],bytes32)\":{\"notice\":\"Redeems `amount` of stablecoins from the system\"},\"redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)\":{\"notice\":\"Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer.\"},\"redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)\":{\"notice\":\"Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`.\"},\"updateNormalizer(uint256,bool)\":{\"notice\":\"Updates the normalizer variable by `amount`\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/Redeemer.sol\":\"Redeemer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRedeemer.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRedeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRedeemer` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRedeemer.sol\\ninterface IRedeemer {\\n  /// @notice Redeems `amount` of stablecoins from the system\\n  /// @param receiver Address which should be receiving the output tokens\\n  /// @param deadline Timestamp before which the redemption should have occured\\n  /// @param minAmountOuts Minimum amount of each token given back in the redemption to obtain\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the output list the caller was\\n  /// quoted, as returned by `quoteRedemptionCurve`. The redemption reverts if the live list differs, since\\n  /// `minAmountOuts` is positional and a collateral rotation can change which token each entry protects\\n  /// @return tokens List of tokens returned\\n  /// @return amounts Amount given for each token in the `tokens` array\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for\\n  /// which the Parallelizer system will not try to do a transfer to `receiver`.\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP\\n  /// transfer.\\n  /// @dev The signed EIP-3009 nonce MUST equal `LibAuthorization.computeRedeemNonce(...)` so that\\n  /// mutating `receiver`, `amount`, `deadline`, `minAmountOuts`, `forfeitTokens` or `expectedTokensHash`\\n  /// invalidates the signature. `authData.nonce` carries the caller-chosen `userSalt`.\\n  /// @dev `expectedTokensHash` matters most here: a signature stays executable for its whole validity\\n  /// window, so without it a relayer could hold one until a collateral rotation reshuffles the output list\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block\\n  /// @return tokens List of tokens that would be given\\n  /// @return amounts Amount that would be obtained for each token in the `tokens` array\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts);\\n\\n  /// @notice Updates the normalizer variable by `amount`\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x3362bd4532915b6e2b26b2fdc967a89ea66de5ea5f669d7a621ee69d75c02273\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/IEIP3009.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\n/// @title IEIP3009\\n/// @notice Interface for EIP-3009: Transfer With Authorization\\ninterface IEIP3009 {\\n  /// @notice Execute a transfer with a signed authorization (EOA signature)\\n  /// @dev SECURITY: anyone may submit this call (no `msg.sender` restriction). Integrators that\\n  /// pair the transfer with downstream logic (e.g. swap, deposit, redeem) MUST use\\n  /// `receiveWithAuthorization` instead: a mempool watcher can otherwise frontrun the original\\n  /// transaction with a raw `transferWithAuthorization`, burning the nonce so the original\\n  /// reverts while the funds still move - causing the post-transfer logic to be skipped.\\n  /// Use this primitive only for direct payouts to a passive recipient (`msg.sender != to`).\\n  /// @param from The address of the sender\\n  /// @param to The address of the recipient\\n  /// @param value The amount of tokens to transfer\\n  /// @param validAfter The timestamp after which the authorization is valid\\n  /// @param validBefore The timestamp before which the authorization is valid\\n  /// @param nonce The nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Execute a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev SECURITY: see the EOA overload - this primitive is frontrun-prone and must not be used\\n  /// when the transfer is bound to follow-on logic. Use `receiveWithAuthorization` in that case.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function transferWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EOA signature)\\n  /// @dev The caller must be the payee (`to` address). This has an additional check to ensure\\n  /// that the payee's address matches the caller of this function to prevent front-running attacks.\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    uint8 v,\\n    bytes32 r,\\n    bytes32 s\\n  )\\n    external;\\n\\n  /// @notice Receive a transfer with a signed authorization (EIP-1271 compatible)\\n  /// @dev The caller must be the payee (`to` address)\\n  /// @param from The payer's address (Authorizer)\\n  /// @param to The payee's address\\n  /// @param value The amount to be transferred\\n  /// @param validAfter The time after which this is valid (unix time)\\n  /// @param validBefore The time before which this is valid (unix time)\\n  /// @param nonce The nonce\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function receiveWithAuthorization(\\n    address from,\\n    address to,\\n    uint256 value,\\n    uint256 validAfter,\\n    uint256 validBefore,\\n    bytes32 nonce,\\n    bytes calldata signature\\n  )\\n    external;\\n\\n  /// @notice Attempt to cancel an authorization\\n  /// @dev Works only if the authorization is not yet used.\\n  /// EOA wallet signatures should be packed in the order of r, s, v.\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param v The recovery id of the signature\\n  /// @param r The r value of the signature\\n  /// @param s The s value of the signature\\n  function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external;\\n\\n  /// @notice Cancel an authorization (EIP-1271 compatible)\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @param signature The signature bytes signed by an EOA wallet or a contract wallet\\n  function cancelAuthorization(address authorizer, bytes32 nonce, bytes calldata signature) external;\\n\\n  /// @notice Returns the state of an authorization\\n  /// @param authorizer Authorizer's address\\n  /// @param nonce Nonce of the authorization\\n  /// @return true if the nonce is used\\n  function authorizationState(address authorizer, bytes32 nonce) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xe34cfb584a925054c2e3569c4401c619cd2b928a7b9da04537e71a9089edf55a\",\"license\":\"MIT\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/Redeemer.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\nimport { IRedeemer } from \\\"contracts/interfaces/IRedeemer.sol\\\";\\nimport { IEIP3009 } from \\\"contracts/interfaces/external/IEIP3009.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\nimport { LibAuthorization } from \\\"../libraries/LibAuthorization.sol\\\";\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibWhitelist } from \\\"../libraries/LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title Redeemer\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `Redeemer` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/Redeemer.sol\\ncontract Redeemer is IRedeemer, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  event Redeemed(\\n    uint256 amount,\\n    address[] tokens,\\n    uint256[] amounts,\\n    address[] forfeitTokens,\\n    address indexed from,\\n    address indexed to\\n  );\\n  event NormalizerUpdated(uint256 newNormalizerValue);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev The `minAmountOuts` list must reflect the amount of `tokens` returned\\n  /// @dev In normal conditions, the amount of tokens outputted by this function should be the amount\\n  /// of collateral assets supported by the system, following their order in the `collateralList`.\\n  /// @dev If one collateral has its liquidity managed through strategies, then it's possible that this asset\\n  /// has sub-collaterals with it. In this situation, these sub-collaterals may be sent during the redemption\\n  /// process and the `minAmountOuts` will be bigger than the `collateralList` length. If there are 3 collateral\\n  /// assets and the 2nd collateral asset in the list (at index 1) consists of 3 sub-collaterals, then the ordering\\n  /// of the token list will be as follows:\\n  /// `[collat 1, sub-collat 1 of collat 2, sub-collat 2 of collat 2, sub-collat 3 of collat 2, collat 3]`\\n  /// @dev The list of tokens outputted (and hence the minimum length of the `minAmountOuts` list) can be obtained\\n  /// by calling the `quoteRedemptionCurve` function\\n  /// @dev Tokens requiring a whitelist must be forfeited if the redemption is to an address that is not in the\\n  /// whitelist, otherwise this function reverts\\n  /// @dev No approval is needed before calling this function\\n  function redeem(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, new address[](0), expectedTokensHash, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev Beware that if a token is given in the `forfeitTokens` list, the redemption will not try to send token\\n  /// even if it has enough immediately available to send the amount\\n  function redeemWithForfeit(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, \\\"\\\");\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function redeemWithAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    external\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    return _redeem(amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  /// @dev This function may be called by trusted addresses: these could be for instance savings contract\\n  /// minting stablecoins when they notice a profit\\n  function updateNormalizer(uint256 amount, bool increase) external returns (uint256) {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && s.transmuterStorage().isTrusted[msg.sender] == 0) {\\n      revert NotTrusted();\\n    }\\n    return _updateNormalizer(amount, increase);\\n  }\\n\\n  /// @inheritdoc IRedeemer\\n  function quoteRedemptionCurve(uint256 amount)\\n    external\\n    view\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    (tokens, amounts,) = _quoteRedemptionCurve(amount);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Working set passed by reference between `_redeem` and its loop helper, so the call\\n  /// site stays under the EVM stack-depth limit when compiling without via-IR.\\n  struct RedemptionExecution {\\n    uint256 amount;\\n    address from;\\n    address to;\\n    address[] tokens;\\n    uint256[] amounts;\\n    uint256[] subCollateralsTracker;\\n    uint256[] minAmountOuts;\\n    address[] forfeitTokens;\\n  }\\n\\n  /// @notice Internal function of the `redeem` function in the `Redeemer` contract\\n  function _redeem(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    nonReentrant\\n    returns (address[] memory tokens, uint256[] memory amounts)\\n  {\\n    if (s.transmuterStorage().isRedemptionLive == 0) revert Paused();\\n    if (block.timestamp > deadline) revert TooLate();\\n\\n    RedemptionExecution memory redemption;\\n    redemption.amount = amount;\\n    redemption.to = to;\\n    redemption.minAmountOuts = minAmountOuts;\\n    redemption.forfeitTokens = forfeitTokens;\\n\\n    (redemption.tokens, redemption.amounts, redemption.subCollateralsTracker) = _quoteRedemptionCurve(amount);\\n    if (redemption.amounts.length != minAmountOuts.length) revert InvalidLengths();\\n    // `minAmountOuts` is positional, so it only protects quantities. Binding the output list itself is what\\n    // ties each minimum to the token it was quoted against, across a collateral rotation\\n    if (keccak256(abi.encodePacked(redemption.tokens)) != expectedTokensHash) revert UnexpectedRedemptionTokens();\\n    _updateNormalizer(amount, false);\\n\\n    redemption.from =\\n      _consumeAuthAndBurn(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n\\n    _distributeRedemption(redemption);\\n    emit Redeemed(\\n      redemption.amount,\\n      redemption.tokens,\\n      redemption.amounts,\\n      redemption.forfeitTokens,\\n      redemption.from,\\n      redemption.to\\n    );\\n    return (redemption.tokens, redemption.amounts);\\n  }\\n\\n  /// @notice Releases each non-forfeited collateral output to `redemption.to`. Extracted from `_redeem`\\n  /// so the parent function stays within the EVM stack-depth limit.\\n  function _distributeRedemption(RedemptionExecution memory redemption) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 indexCollateral;\\n    uint256 amountsLength = redemption.amounts.length;\\n    for (uint256 i; i < amountsLength; ++i) {\\n      if (redemption.amounts[i] < redemption.minAmountOuts[i]) revert TooSmallAmountOut();\\n      // If a token is in the `forfeitTokens` list, then it is not sent as part of the redemption process\\n      if (redemption.amounts[i] > 0 && LibHelpers.checkList(redemption.tokens[i], redemption.forfeitTokens) < 0) {\\n        Collateral storage collatInfo = ts.collaterals[collateralListMem[indexCollateral]];\\n        if (collatInfo.onlyWhitelisted > 0 && !LibWhitelist.checkWhitelist(collatInfo.whitelistData, redemption.to)) {\\n          revert NotWhitelisted();\\n        }\\n        if (collatInfo.isManaged > 0) {\\n          LibManager.release(redemption.tokens[i], redemption.to, redemption.amounts[i], collatInfo.managerData.config);\\n        } else {\\n          IERC20(redemption.tokens[i]).safeTransfer(redemption.to, redemption.amounts[i]);\\n        }\\n      }\\n      if (redemption.subCollateralsTracker[indexCollateral] - 1 <= i) ++indexCollateral;\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer (auth flow) or burns directly from\\n  /// `msg.sender`, and returns the address to attribute the `Redeemed` event to.\\n  function _consumeAuthAndBurn(\\n    uint256 amount,\\n    address to,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    ITokenP tokenP = s.transmuterStorage().tokenP;\\n    if (authData.length > 0) {\\n      from = _executeAuthorization(amount, to, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, authData);\\n      tokenP.burnSelf(amount, address(this));\\n    } else {\\n      from = msg.sender;\\n      tokenP.burnSelf(amount, msg.sender);\\n    }\\n  }\\n\\n  /// @notice Pulls the redeem amount from the signer via EIP-3009 `receiveWithAuthorization`,\\n  /// using a derived nonce that binds the full redemption intent.\\n  /// @return from The authorizer address (`params.from`), to attribute the redeem event to\\n  function _executeAuthorization(\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes memory authData\\n  )\\n    internal\\n    returns (address from)\\n  {\\n    AuthorizationParams memory params = abi.decode(authData, (AuthorizationParams));\\n    if (params.value != amount) revert InvalidSwap();\\n    bytes32 derivedNonce = LibAuthorization.computeRedeemNonce(\\n      params.from, amount, receiver, deadline, minAmountOuts, forfeitTokens, expectedTokensHash, params.nonce\\n    );\\n    IEIP3009(address(s.transmuterStorage().tokenP))\\n      .receiveWithAuthorization(\\n        params.from, address(this), params.value, params.validAfter, params.validBefore, derivedNonce, params.signature\\n      );\\n    return params.from;\\n  }\\n\\n  /// @dev This function reverts if `stablecoinsIssued==0`, which is expected behavior as there is nothing to redeem\\n  /// anyway in this case, or if the `amountBurnt` is greater than `stablecoinsIssued`\\n  /// @dev Invariant: `penaltyFactor` is evaluated once at the entry-time `collatRatio` and applied uniformly to the\\n  /// full `amountBurnt`. The curve is not path-integrated, so a single redemption that traverses into a lower-penalty\\n  /// segment still pays the entry-time rate on every unit burned. Splitting the same redemption into smaller calls\\n  /// can yield a strictly better blended rate when the path crosses an ascending segment of the curve. This is a\\n  /// deliberate design choice consistent with penalizing early redemptions during under-collateralization; the gap\\n  /// between single-call and path-integrated pricing scales with the ascending-segment slope and should be\\n  /// considered when calibrating `xRedemptionCurve`/`yRedemptionCurve`.\\n  function _quoteRedemptionCurve(uint256 amountBurnt)\\n    internal\\n    view\\n    returns (address[] memory tokens, uint256[] memory balances, uint256[] memory subCollateralsTracker)\\n  {\\n    uint64 collatRatio;\\n    uint256 stablecoinsIssued;\\n    (collatRatio, stablecoinsIssued, tokens, balances, subCollateralsTracker) = LibGetters.getCollateralRatio();\\n    if (amountBurnt >= stablecoinsIssued) revert CannotBurnAllStableIssued();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    int64[] memory yRedemptionCurveMem = ts.yRedemptionCurve;\\n    uint64 penaltyFactor;\\n    // If the protocol is under-collateralized, a penalty factor is applied to the returned amount of each asset\\n    if (collatRatio < BASE_9) {\\n      uint64[] memory xRedemptionCurveMem = ts.xRedemptionCurve;\\n      penaltyFactor = uint64(LibHelpers.piecewiseLinear(collatRatio, xRedemptionCurveMem, yRedemptionCurveMem));\\n    }\\n\\n    for (uint256 i; i < balances.length; ++i) {\\n      // The amount given for each token in reserves does not depend on the price of the tokens in reserve:\\n      // it is a proportion of the balance for each token computed as the ratio between the stablecoins\\n      // burnt relative to the amount of stablecoins issued.\\n      // If the protocol is over-collateralized, the amount of each token given is inversely proportional\\n      // to the collateral ratio.\\n      balances[i] = collatRatio >= BASE_9\\n        ? (amountBurnt * balances[i] * (uint64(yRedemptionCurveMem[yRedemptionCurveMem.length - 1])))\\n          / (stablecoinsIssued * collatRatio)\\n        : (amountBurnt * balances[i] * penaltyFactor) / (stablecoinsIssued * BASE_9);\\n    }\\n  }\\n\\n  /// @notice Updates the `normalizer` variable used to track stablecoins issued from each asset and globally\\n  function _updateNormalizer(uint256 amount, bool increase) internal returns (uint256 newNormalizerValue) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 _normalizer = ts.normalizer;\\n    uint256 _normalizedStables = ts.normalizedStables;\\n    // In case of an increase, the update formula used is the simplified version of the formula below:\\n    /*\\n            _normalizer * (BASE_27 + BASE_27 * amount / stablecoinsIssued) / BASE_27\\n        = _normalizer + (_normalizer * BASE_27 * amount * (BASE_27 / (_normalizedStables * normalizer))) / BASE_27\\n             = _normalizer + BASE_27 * amount / _normalizedStables\\n        */\\n    if (increase) {\\n      newNormalizerValue = _normalizer + (amount * BASE_27) / _normalizedStables;\\n    } else {\\n      newNormalizerValue = _normalizer - (amount * BASE_27) / _normalizedStables;\\n    }\\n    // If the `normalizer` gets too small or too big, it must be renormalized to later avoid the propagation of\\n    // rounding errors, as well as overflows. In this case, the function has to iterate through all the\\n    // supported collateral assets\\n    if (newNormalizerValue <= BASE_18 || newNormalizerValue >= BASE_36) {\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 collateralListLength = collateralListMem.length;\\n      // For each asset, we store the actual amount of stablecoins issued based on the `newNormalizerValue`\\n      // (and not a normalized value)\\n      // We ensure to preserve the invariant `sum(collateralNewNormalizedStables) = normalizedStables`\\n      uint128 newNormalizedStables;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        uint128 newCollateralNormalizedStable = ((uint256(ts.collaterals[collateralListMem[i]].normalizedStables)\\n              * newNormalizerValue) / BASE_27)\\n        .toUint128();\\n        newNormalizedStables += newCollateralNormalizedStable;\\n        ts.collaterals[collateralListMem[i]].normalizedStables = uint216(newCollateralNormalizedStable);\\n      }\\n      ts.normalizedStables = newNormalizedStables;\\n      newNormalizerValue = BASE_27;\\n    }\\n    ts.normalizer = newNormalizerValue.toUint128();\\n    if (!increase && ts.normalizedStables == 0) revert CannotBurnAllStableIssued();\\n    emit NormalizerUpdated(newNormalizerValue);\\n  }\\n}\\n\",\"keccak256\":\"0x1a67602de708b202cbfb4311b65c8e28294c043d059c53c66dcd9c7b1512d3c0\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibAuthorization.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\n/// @title LibAuthorization\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Derives the EIP-3009 nonce that binds the Parallelizer's `*WithAuthorization` entry\\n/// points to their full swap/redeem intent (output `to`, slippage, deadline, ...), closing the\\n/// front-running gap left by vanilla `receiveWithAuthorization` which only commits to the token\\n/// transfer itself.\\n/// @dev Off-chain, the authorizer signs a standard EIP-3009 `ReceiveWithAuthorization` with\\n/// `nonce = compute*Nonce(...)`. The facet recomputes the same value from the call arguments and\\n/// forwards it to the token; tampering with any bound field makes the signature invalid. Replay\\n/// protection is provided by the token's own `authorizationStates` mapping; retries use a fresh\\n/// `userSalt`.\\nlibrary LibAuthorization {\\n  // keccak256(\\\"SwapExactInputWithAuthorization(address from,address tokenIn,address tokenOut,uint256 amountIn,uint256\\n  // amountOutMin,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x9be969f74c66b263054aa69cfac8412777a0dc17ab007f81682c6b156ba06d79;\\n\\n  // keccak256(\\\"SwapExactOutputWithAuthorization(address from,address tokenIn,address tokenOut,uint256\\n  // amountOut,uint256 amountInMax,address to,uint256 deadline,bytes32 userSalt)\\\")\\n  bytes32 internal constant SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH =\\n    0x41378613b6b468c26472b6d9a40faaeaf3c63b23ae57d1d7e3a7c3d2c356b1ed;\\n\\n  // keccak256(\\\"RedeemWithAuthorization(address from,uint256 amount,address receiver,uint256 deadline,bytes32\\n  // minAmountOutsHash,bytes32 forfeitTokensHash,bytes32 expectedTokensHash,bytes32 userSalt)\\\")\\n  bytes32 internal constant REDEEM_WITH_AUTHORIZATION_TYPEHASH =\\n    0xb6577f08e668b53303325a19233e8315142d69bedb6d7e1d8d0e9af2473486d4;\\n\\n  function computeSwapExactInputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountIn,\\n    uint256 amountOutMin,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_INPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountIn,\\n        amountOutMin,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  function computeSwapExactOutputNonce(\\n    address from,\\n    address tokenIn,\\n    address tokenOut,\\n    uint256 amountOut,\\n    uint256 amountInMax,\\n    address to,\\n    uint256 deadline,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        SWAP_EXACT_OUTPUT_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        tokenIn,\\n        tokenOut,\\n        amountOut,\\n        amountInMax,\\n        to,\\n        deadline,\\n        userSalt\\n      )\\n    );\\n  }\\n\\n  /// @param expectedTokensHash `keccak256(abi.encodePacked(tokens))` over the redemption output list the\\n  /// authorizer was quoted, binding token identity and ordering rather than raw amounts alone\\n  function computeRedeemNonce(\\n    address from,\\n    uint256 amount,\\n    address receiver,\\n    uint256 deadline,\\n    uint256[] memory minAmountOuts,\\n    address[] memory forfeitTokens,\\n    bytes32 expectedTokensHash,\\n    bytes32 userSalt\\n  )\\n    internal\\n    pure\\n    returns (bytes32)\\n  {\\n    return keccak256(\\n      abi.encode(\\n        REDEEM_WITH_AUTHORIZATION_TYPEHASH,\\n        from,\\n        amount,\\n        receiver,\\n        deadline,\\n        keccak256(abi.encodePacked(minAmountOuts)),\\n        keccak256(abi.encodePacked(forfeitTokens)),\\n        expectedTokensHash,\\n        userSalt\\n      )\\n    );\\n  }\\n}\\n\",\"keccak256\":\"0x195b02224ec034756820857b7f88acc6ace194d00a68a9a6f0bcb8adf38963c8\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -407,13 +428,13 @@
       "quoteRedemptionCurve(uint256)": {
         "notice": "Simulate the exact output that a redemption of `amount` of stablecoins would give at a given block"
       },
-      "redeem(uint256,address,uint256,uint256[])": {
+      "redeem(uint256,address,uint256,uint256[],bytes32)": {
         "notice": "Redeems `amount` of stablecoins from the system"
       },
-      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes)": {
+      "redeemWithAuthorization(uint256,address,uint256,uint256[],address[],bytes32,bytes)": {
         "notice": "Same as `redeemWithForfeit` but using a single EIP-3009 authorization for the tokenP transfer."
       },
-      "redeemWithForfeit(uint256,address,uint256,uint256[],address[])": {
+      "redeemWithForfeit(uint256,address,uint256,uint256[],address[],bytes32)": {
         "notice": "Same as the redeem function above with the additional feature to specify a list of `forfeitTokens` for which the Parallelizer system will not try to do a transfer to `receiver`."
       },
       "updateNormalizer(uint256,bool)": {
@@ -424,13 +445,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "nonce": "0xc0",
-    "hash": "0x864813682e8f46c2c5b0f71bfc457a55609af9662826bb4e582276856059d93a",
+    "nonce": "0xda",
+    "hash": "0x1aa360cf2ac6aa671df115dcdd103776903e1454822864559f671234057683eb",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
-    "blockHash": "0xf4373a86f7d4ac5d589295f9f776d88ecfaac4963b807d97c734482692461c1c",
-    "blockNumber": "0x2765d37",
-    "transactionIndex": "0x4"
+    "blockHash": "0x1c6e4b009d5a84471993c3e5722be38f102176718b4b57d821086e5d8f7de24e",
+    "blockNumber": "0x2e5a06a",
+    "transactionIndex": "0x1"
   }
 }
\ No newline at end of file
diff --git a/deployments/hyperevm/RewardHandler.json b/deployments/hyperevm/RewardHandler.json
index 066aa85..1a5d6cc 100644
--- a/deployments/hyperevm/RewardHandler.json
+++ b/deployments/hyperevm/RewardHandler.json
@@ -1,5 +1,5 @@
 {
-  "address": "0xabe6b4b321a5d07fafb7350dae06cfbdac3e81ae",
+  "address": "0x619eb29e1643cde2b2117d6b7524848f540346f3",
   "abi": [
     {
       "inputs": [],
@@ -18,12 +18,12 @@
     },
     {
       "inputs": [],
-      "name": "OdosSwapFailed",
+      "name": "ReentrantCall",
       "type": "error"
     },
     {
       "inputs": [],
-      "name": "ReentrantCall",
+      "name": "RewardSwapFailed",
       "type": "error"
     },
     {
@@ -42,6 +42,11 @@
       "name": "TooSmallAmountOut",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -88,8 +93,8 @@
   ],
   "contractName": "RewardHandler",
   "sourceName": "contracts/parallelizer/facets/RewardHandler.sol",
-  "bytecode": "0x6080604052348015600e575f5ffd5b50610fa08061001c5f395ff3fe608060405234801561000f575f5ffd5b5060043610610029575f3560e01c806305b419341461002d575b5f5ffd5b61004061003b366004610cab565b610052565b60405190815260200160405180910390f35b7f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7580545f919060ff600160a81b90910416600119016100bd576040517f37ed32e800000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b805460ff60a81b191675020000000000000000000000000000000000000000001781557f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7561010c335f366107c5565b1580156101275750335f908152600782016020526040902054155b1561015e576040517fc22a648e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f816002018054806020026020016040519081016040528092919081815260200182805480156101b557602002820191905f5260205f20905b81546001600160a01b03168152600190910190602001808311610197575b505050505090505f815190505f8167ffffffffffffffff8111156101db576101db610c3f565b604051908082528060200260200182016040528015610204578160200160208202803683370190505b5090505f5b828110156102ba5783818151811061022357610223610d2f565b60209081029190910101516040516370a0823160e01b81523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa158015610271573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906102959190610d43565b8282815181106102a7576102a7610d2f565b6020908102919091010152600101610209565b5083546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a0823190602401602060405180830381865afa158015610300573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103249190610d43565b90505f5f73cf5540fffcdc3d510b18bfca6d2b9987b07725596001600160a01b03168a6040516103549190610d5a565b5f604051808303815f865af19150503d805f811461038d576040519150601f19603f3d011682016040523d82523d5f602084013e610392565b606091505b5091509150816103a5576103a581610911565b86546040516370a0823160e01b815230600482015284916001600160a01b0316906370a0823190602401602060405180830381865afa1580156103ea573d5f5f3e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061040e9190610d43565b1015610446576040517f672215de00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5f5f5b87811015610602575f89828151811061046557610465610d2f565b60209081029190910101516040516370a0823160e01b81523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa1580156104b3573d5f5f3e3d5ffd5b505050506040513d601f19601f820116820180604052508101906104d79190610d43565b90508782815181106104eb576104eb610d2f565b602002602001015181101561051357604051631115766760e01b815260040160405180910390fd5b87828151811061052557610525610d2f565b60200260200101518111156105f9576001935089828151811061054a5761054a610d2f565b6020026020010151925087828151811061056657610566610d2f565b6020026020010151816105799190610d70565b9c508e8d10156105b5576040517fa1aabbe100000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b826001600160a01b03167fbe1da12e92b73d3ecd35edcc32270e8ffaa4ee9fe30f671989b3d2e88a2c2ea28e6040516105f091815260200190565b60405180910390a25b5060010161044a565b508161062157604051631115766760e01b815260040160405180910390fd5b6001600160a01b0381165f9081527f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c7a60205260409020805460ff16156107a25761070b6106fa82600701600101805461067990610d95565b80601f01602080910402602001604051908101604052809291908181526020018280546106a590610d95565b80156106f05780601f106106c7576101008083540402835291602001916106f0565b820191905f5260205f20905b8154815290600101906020018083116106d357829003601f168201915b5050505050610952565b6001600160a01b038416908e61099e565b6107a28c82600701600101805461072190610d95565b80601f016020809104026020016040519081016040528092919081815260200182805461074d90610d95565b80156107985780601f1061076f57610100808354040283529160200191610798565b820191905f5260205f20905b81548152906001019060200180831161077b57829003601f168201915b5050505050610a23565b5050885460ff60a81b1916600160a81b1790985550969998505050505050505050565b7fc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131d545f906001600160a01b031681806108158388306108076004868b8d610dcd565b61081091610df4565b610abd565b91509150816109025763ffffffff8116156108f7577f4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75805460ff60b01b19167601000000000000000000000000000000000000000000001781556040517f94c7d7ee0000000000000000000000000000000000000000000000000000000081526001600160a01b038516906394c7d7ee906108b8908b908b908b90600401610e5a565b5f604051808303815f87803b1580156108cf575f5ffd5b505af11580156108e1573d5f5f3e3d5ffd5b5050825460ff60b01b1916909255506109029050565b5f935050505061090a565b600193505050505b9392505050565b80511561092057805181602001fd5b6040517f45d4013e00000000000000000000000000000000000000000000000000000000815260040160405180910390fd5b5f5f5f61095e84610b95565b30945090925090505f82801561097657610976610e98565b03610997578080602001905181019061098f9190610ec3565b949350505050565b5050919050565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052610a1e908490610bb6565b505050565b5f5f610a2e83610b95565b90925090505f828015610a4357610a43610e98565b03610ab75780806020019051810190610a5c9190610ec3565b6001600160a01b0316632afcf480856040518263ffffffff1660e01b8152600401610a8991815260200190565b5f604051808303815f87803b158015610aa0575f5ffd5b505af1158015610ab2573d5f5f3e3d5ffd5b505050505b50505050565b6040516001600160a01b038085166024830152831660448201527fffffffff00000000000000000000000000000000000000000000000000000000821660648201525f908190819060840160408051601f19818403018152918152602080830180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fb7009613000000000000000000000000000000000000000000000000000000001781525f808052918290528351939450919290918a5afa15610b8b575f516020805191945081901c150291505b5094509492505050565b5f606082806020019051810190610bac9190610ede565b9094909350915050565b5f5f60205f8451602086015f885af180610bd5576040513d5f823e3d81fd5b50505f513d91508115610bec578060011415610bf9565b6001600160a01b0384163b155b15610ab7576040517f5274afe70000000000000000000000000000000000000000000000000000000081526001600160a01b038516600482015260240160405180910390fd5b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f1916810167ffffffffffffffff81118282101715610c7c57610c7c610c3f565b604052919050565b5f67ffffffffffffffff821115610c9d57610c9d610c3f565b50601f01601f191660200190565b5f5f60408385031215610cbc575f5ffd5b82359150602083013567ffffffffffffffff811115610cd9575f5ffd5b8301601f81018513610ce9575f5ffd5b8035610cfc610cf782610c84565b610c53565b818152866020838501011115610d10575f5ffd5b816020840160208301375f602083830101528093505050509250929050565b634e487b7160e01b5f52603260045260245ffd5b5f60208284031215610d53575f5ffd5b5051919050565b5f82518060208501845e5f920191825250919050565b81810381811115610d8f57634e487b7160e01b5f52601160045260245ffd5b92915050565b600181811c90821680610da957607f821691505b602082108103610dc757634e487b7160e01b5f52602260045260245ffd5b50919050565b5f5f85851115610ddb575f5ffd5b83861115610de7575f5ffd5b5050820193919092039150565b80357fffffffff000000000000000000000000000000000000000000000000000000008116906004841015610e53577fffffffff00000000000000000000000000000000000000000000000000000000808560040360031b1b82161691505b5092915050565b6001600160a01b038416815260406020820152816040820152818360608301375f818301606090810191909152601f909201601f1916010192915050565b634e487b7160e01b5f52602160045260245ffd5b6001600160a01b0381168114610ec0575f5ffd5b50565b5f60208284031215610ed3575f5ffd5b815161090a81610eac565b5f5f60408385031215610eef575f5ffd5b825160018110610efd575f5ffd5b602084015190925067ffffffffffffffff811115610f19575f5ffd5b8301601f81018513610f29575f5ffd5b8051610f37610cf782610c84565b818152866020838501011115610f4b575f5ffd5b8160208401602083015e5f60208383010152809350505050925092905056fea264697066735822122061f2e881fc702fd22da9d01258cc5b103013facf6eb83ae8ddf66dab5c9a1c6d64736f6c634300081c0033",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -108,7 +113,7 @@
     "kind": "dev",
     "methods": {
       "sellRewards(uint256,bytes)": {
-        "details": "It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to Odos router for the token to be swapped"
+        "details": "It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to the configured `swapRouter` for the token to be swapped"
       }
     },
     "title": "RewardHandler",
@@ -117,9 +122,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "800000",
-        "executionCost": "829",
-        "totalCost": "800829"
+        "codeDepositCost": "810200",
+        "executionCost": "842",
+        "totalCost": "811042"
       },
       "external": {
         "sellRewards(uint256,bytes)": "infinite"
@@ -129,7 +134,7 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokens\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OdosSwapFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenObtained\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"balanceUpdate\",\"type\":\"uint256\"}],\"name\":\"RewardsSoldFor\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"sellRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `RewardHandler` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"details\":\"It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to Odos router for the token to be swapped\"}},\"title\":\"RewardHandler\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"notice\":\"IRewardHandler\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/RewardHandler.sol\":\"RewardHandler\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a odos call\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to odos\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xff2afcbc8d1c25297324159d3684a323e60b3c9408129aba70d3d6938d093255\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/RewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { IRewardHandler } from \\\"contracts/interfaces/IRewardHandler.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title RewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `RewardHandler` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\\ncontract RewardHandler is IRewardHandler, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n\\n  event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);\\n\\n  /// @notice IRewardHandler\\n  /// @dev It is impossible to sell a token that is a collateral through this function\\n  /// @dev Trusted sellers and governance only may call this function\\n  /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval\\n  /// transaction to Odos router for the token to be swapped\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    address[] memory list = ts.collateralList;\\n    uint256 listLength = list.length;\\n    uint256[] memory balances = new uint256[](listLength);\\n    // Getting the balances of all collateral assets of the protocol to see if those do not decrease during\\n    // the swap: this is the only way to check that collateral assets have not been sold\\n    // Not checking the `subCollaterals` here as swaps should try to increase the balance of one collateral\\n    for (uint256 i; i < listLength; ++i) {\\n      balances[i] = IERC20(list[i]).balanceOf(address(this));\\n    }\\n    uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));\\n    //solhint-disable-next-line\\n    (bool success, bytes memory result) = ODOS_ROUTER.call(payload);\\n    if (!success) _revertBytes(result);\\n    if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();\\n    bool hasIncreased;\\n    address collateral;\\n    for (uint256 i; i < listLength; ++i) {\\n      uint256 newBalance = IERC20(list[i]).balanceOf(address(this));\\n      if (newBalance < balances[i]) {\\n        revert InvalidSwap();\\n      } else if (newBalance > balances[i]) {\\n        hasIncreased = true;\\n        collateral = list[i];\\n        amountOut = newBalance - balances[i];\\n        if (amountOut < minAmountOut) revert TooSmallAmountOut();\\n        emit RewardsSoldFor(collateral, amountOut);\\n      }\\n    }\\n    if (!hasIncreased) revert InvalidSwap();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      IERC20(collateral).safeTransfer(LibManager.transferRecipient(collatInfo.managerData.config), amountOut);\\n      LibManager.invest(amountOut, collatInfo.managerData.config);\\n    }\\n  }\\n\\n  /// @notice Processes odos revert messages\\n  function _revertBytes(bytes memory errMsg) private pure {\\n    if (errMsg.length > 0) {\\n      //solhint-disable-next-line\\n      assembly (\\\"memory-safe\\\") {\\n        revert(add(32, errMsg), mload(errMsg))\\n      }\\n    }\\n    revert OdosSwapFailed();\\n  }\\n}\\n\",\"keccak256\":\"0xf01917011b3966f1783fa024ce6c56b5294ef0f65531bdc3f2e068649cd45038\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"InvalidSwap\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidTokens\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrantCall\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RewardSwapFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TooSmallAmountOut\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"tokenObtained\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"balanceUpdate\",\"type\":\"uint256\"}],\"name\":\"RewardsSoldFor\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"payload\",\"type\":\"bytes\"}],\"name\":\"sellRewards\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `RewardHandler` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\",\"errors\":{\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"details\":\"It is impossible to sell a token that is a collateral through this functionTrusted sellers and governance only may call this functionOnly governance can set which tokens can be swapped through this function by passing a prior approval transaction to the configured `swapRouter` for the token to be swapped\"}},\"title\":\"RewardHandler\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"sellRewards(uint256,bytes)\":{\"notice\":\"IRewardHandler\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/RewardHandler.sol\":\"RewardHandler\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IRewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IRewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IRewardHandler` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IRewardHandler.sol\\ninterface IRewardHandler {\\n  /// @notice Sells some external tokens through a call to the configured swap router\\n  /// @param minAmountOut Minimum amount of the outToken to get\\n  /// @param payload Payload to pass to the swap router\\n  /// @return amountOut Amount obtained of the outToken\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external returns (uint256 amountOut);\\n}\\n\",\"keccak256\":\"0xb3604f35c5bb44791020588e00774299a6a4adae17d62d1e53cd8be86da6b709\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/RewardHandler.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { IRewardHandler } from \\\"contracts/interfaces/IRewardHandler.sol\\\";\\n\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title RewardHandler\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `RewardHandler` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/RewardHandler.sol\\ncontract RewardHandler is IRewardHandler, AccessManagedModifiers {\\n  using SafeERC20 for IERC20;\\n\\n  event RewardsSoldFor(address indexed tokenObtained, uint256 balanceUpdate);\\n\\n  /// @notice IRewardHandler\\n  /// @dev It is impossible to sell a token that is a collateral through this function\\n  /// @dev Trusted sellers and governance only may call this function\\n  /// @dev Only governance can set which tokens can be swapped through this function by passing a prior approval\\n  /// transaction to the configured `swapRouter` for the token to be swapped\\n  function sellRewards(uint256 minAmountOut, bytes memory payload) external nonReentrant returns (uint256 amountOut) {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data) && ts.isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    address[] memory list = ts.collateralList;\\n    uint256 listLength = list.length;\\n    uint256[] memory balances = new uint256[](listLength);\\n    // Getting the balances of all collateral assets of the protocol to see if those do not decrease during\\n    // the swap: this is the only way to check that collateral assets have not been sold\\n    // Not checking the `subCollaterals` here as swaps should try to increase the balance of one collateral\\n    for (uint256 i; i < listLength; ++i) {\\n      balances[i] = IERC20(list[i]).balanceOf(address(this));\\n    }\\n    uint256 tokenPBalance = IERC20(address(ts.tokenP)).balanceOf(address(this));\\n    address swapRouter = ts.swapRouter;\\n    if (swapRouter == address(0)) revert ZeroAddress();\\n    //solhint-disable-next-line\\n    (bool success, bytes memory result) = swapRouter.call(payload);\\n    if (!success) _revertBytes(result);\\n    if (IERC20(address(ts.tokenP)).balanceOf(address(this)) < tokenPBalance) revert InvalidTokens();\\n    bool hasIncreased;\\n    address collateral;\\n    for (uint256 i; i < listLength; ++i) {\\n      uint256 newBalance = IERC20(list[i]).balanceOf(address(this));\\n      if (newBalance < balances[i]) {\\n        revert InvalidSwap();\\n      } else if (newBalance > balances[i]) {\\n        hasIncreased = true;\\n        collateral = list[i];\\n        amountOut = newBalance - balances[i];\\n        if (amountOut < minAmountOut) revert TooSmallAmountOut();\\n        emit RewardsSoldFor(collateral, amountOut);\\n      }\\n    }\\n    if (!hasIncreased) revert InvalidSwap();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      IERC20(collateral).safeTransfer(LibManager.transferRecipient(collatInfo.managerData.config), amountOut);\\n      LibManager.invest(amountOut, collatInfo.managerData.config);\\n    }\\n  }\\n\\n  /// @notice Processes the router's revert messages\\n  function _revertBytes(bytes memory errMsg) private pure {\\n    if (errMsg.length > 0) {\\n      //solhint-disable-next-line\\n      assembly (\\\"memory-safe\\\") {\\n        revert(add(32, errMsg), mload(errMsg))\\n      }\\n    }\\n    revert RewardSwapFailed();\\n  }\\n}\\n\",\"keccak256\":\"0xa4e2fdeaaa43d78dfe1a81f458108856ebc92f27a7194e6293ac3c5084325beb\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
@@ -145,13 +150,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "nonce": "0xc1",
-    "hash": "0x8c0d1c625b2aa9313077be501076bfd40a7c50e334b89ef21f71158888bb93d6",
+    "nonce": "0xdb",
+    "hash": "0x9fd0ecc18415f626b0c8231fc061324f9cc1a0491c4204c12ea32b33ee89cb12",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
-    "blockHash": "0x40fd062aa586d13b1c95cf150e435273c525ffdec16c01989dbc9054e19f4deb",
-    "blockNumber": "0x2765db1",
-    "transactionIndex": "0x2"
+    "blockHash": "0x53d1fcd4815fb59635f9e3ca2f4656dd60b02c6ae52305ca80dde63cdc260800",
+    "blockNumber": "0x2e5a0a7",
+    "transactionIndex": "0x1"
   }
 }
\ No newline at end of file
diff --git a/deployments/hyperevm/SettersGovernor.json b/deployments/hyperevm/SettersGovernor.json
index 82ecbc8..ba43640 100644
--- a/deployments/hyperevm/SettersGovernor.json
+++ b/deployments/hyperevm/SettersGovernor.json
@@ -1,5 +1,5 @@
 {
-  "address": "0x01bf702c4409eb71c8c9dc9fe03403b3791862fb",
+  "address": "0xf51edb90c72f86c72fdf8cc20557764abb44845e",
   "abi": [
     {
       "inputs": [],
@@ -57,6 +57,11 @@
       "name": "InvalidParams",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "InvalidPayee",
+      "type": "error"
+    },
     {
       "inputs": [],
       "name": "InvalidRate",
@@ -135,6 +140,11 @@
       "name": "SafeERC20FailedOperation",
       "type": "error"
     },
+    {
+      "inputs": [],
+      "name": "ZeroAddress",
+      "type": "error"
+    },
     {
       "inputs": [],
       "name": "ZeroAmount",
@@ -285,6 +295,31 @@
       "name": "OracleSet",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "collateral",
+          "type": "address"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "previousTarget",
+          "type": "uint256"
+        },
+        {
+          "indexed": false,
+          "internalType": "uint256",
+          "name": "newTarget",
+          "type": "uint256"
+        }
+      ],
+      "name": "OracleTargetUpdated",
+      "type": "event"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -405,6 +440,19 @@
       "name": "SurplusBufferRatioUpdated",
       "type": "event"
     },
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "swapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "SwapRouterUpdated",
+      "type": "event"
+    },
     {
       "anonymous": false,
       "inputs": [
@@ -601,6 +649,19 @@
       "stateMutability": "nonpayable",
       "type": "function"
     },
+    {
+      "inputs": [
+        {
+          "internalType": "address",
+          "name": "swapRouter",
+          "type": "address"
+        }
+      ],
+      "name": "setSwapRouter",
+      "outputs": [],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
     {
       "inputs": [
         {
@@ -712,8 +773,8 @@
   ],
   "contractName": "SettersGovernor",
   "sourceName": "contracts/parallelizer/facets/SettersGovernor.sol",
-  "bytecode": "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",
-  "deployedBytecode": "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",
+  "bytecode": "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",
+  "deployedBytecode": "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",
   "linkReferences": {},
   "deployedLinkReferences": {},
   "immutableReferences": {},
@@ -759,6 +820,9 @@
       "setCollateralManager(address,bool,(address[],bytes))": {
         "details": "Funds need to have been withdrawn from the eventual previous manager prior to this call"
       },
+      "setSwapRouter(address)": {
+        "details": "The payload is executed with a raw call, so any router can be configured. It is chain specific and must be set on every deployment before rewards can be sold"
+      },
       "updatePayees(address[],uint256[],bool)": {
         "params": {
           "_payees": "The new payee addresses",
@@ -782,9 +846,9 @@
   "evm": {
     "gasEstimates": {
       "creation": {
-        "codeDepositCost": "3353000",
-        "executionCost": "3729",
-        "totalCost": "3356729"
+        "codeDepositCost": "3440800",
+        "executionCost": "3842",
+        "totalCost": "3444642"
       },
       "external": {
         "addCollateral(address)": "infinite",
@@ -795,6 +859,7 @@
         "setAccessManager(address)": "infinite",
         "setCollateralManager(address,bool,(address[],bytes))": "infinite",
         "setOracle(address,bytes)": "infinite",
+        "setSwapRouter(address)": "infinite",
         "setWhitelistStatus(address,uint8,bytes)": "infinite",
         "toggleTrusted(address,uint8)": "infinite",
         "updateOracle(address)": "infinite",
@@ -804,12 +869,17 @@
       }
     }
   },
-  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AboveCap\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyAdded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CollateralBacked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccessManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParams\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidWhitelistStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ManagerHasAssets\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OracleUpdateFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentAllowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requestedDecrease\",\"type\":\"uint256\"}],\"name\":\"SafeERC20FailedDecreaseAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"indexed\":false,\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"CollateralManagerSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"}],\"name\":\"CollateralWhitelistStatusUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleasedToPayee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"OracleSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"PayeeAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"ReservesAdjusted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"SlippageToleranceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"SurplusBufferRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isTrusted\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"enum TrustedType\",\"name\":\"trustedType\",\"type\":\"uint8\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"addCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"adjustStablecoins\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"changeAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"}],\"name\":\"revokeCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAccessManager\",\"type\":\"address\"}],\"name\":\"setAccessManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"setCollateralManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"setOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"}],\"name\":\"setWhitelistStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"enum TrustedType\",\"name\":\"t\",\"type\":\"uint8\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"updateOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_payees\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_shares\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"_skipRelease\",\"type\":\"bool\"}],\"name\":\"updatePayees\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"updateSlippageTolerance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"updateSurplusBufferRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `SettersGovernor` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedDecreaseAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failed `decreaseAllowance` request.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"addCollateral(address)\":{\"details\":\"Collateral assets with a fee on transfer are not supported by the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"details\":\"The amount passed here must be an absolute amount\"},\"changeAllowance(address,address,uint256)\":{\"details\":\"This function can typically be used to grant allowance to a newly added manager for it to pull the funds associated to the collateral it corresponds to\"},\"recoverERC20(address,address,address,uint256)\":{\"details\":\"No check is made on the collateral that is redeemed: this function could typically be used by a governance during a manual rebalance of the reserves of the system`collateral` is different from `token` only in the case of a managed collateral\"},\"revokeCollateral(address,bool)\":{\"details\":\"Require `collatInfo.normalizedStables == 0`, that is to say that the collateral is not used to back stablesThe system may still have a non null balance of the collateral that is revoked: this should later be handled through a recoverERC20 callFunds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is true\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"details\":\"Funds need to have been withdrawn from the eventual previous manager prior to this call\"},\"updatePayees(address[],uint256[],bool)\":{\"params\":{\"_payees\":\"The new payee addresses\",\"_shares\":\"The new shares for each payee\",\"_skipRelease\":\"If true, skips the automatic income release before updating\"}},\"updateSlippageTolerance(address,uint256)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when calling the `processSurplus` function\"},\"updateSurplusBufferRatio(uint64)\":{\"details\":\"The surplus buffer ratio is the minimum collateral ratio required after surplus processing\",\"params\":{\"_surplusBufferRatio\":\"The new surplus buffer ratio in BASE_9\"}}},\"title\":\"SettersGovernor\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"addCollateral(address)\":{\"notice\":\"Add `collateral` as a supported collateral in the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"notice\":\"Adjusts the amount of stablecoins issued from `collateral` by `amount`\"},\"changeAllowance(address,address,uint256)\":{\"notice\":\"Sets the allowance of the contract on `token` for `spender` to `amount`\"},\"recoverERC20(address,address,address,uint256)\":{\"notice\":\"Recovers `amount` of `token` from the Parallelizer contract\"},\"revokeCollateral(address,bool)\":{\"notice\":\"Revokes `collateral` from the system\"},\"setAccessManager(address)\":{\"notice\":\"Sets a new access manager address\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"notice\":\"Sets (or unsets) a collateral manager  `collateral`\"},\"setOracle(address,bytes)\":{\"notice\":\"Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations\"},\"setWhitelistStatus(address,uint8,bytes)\":{\"notice\":\"Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist\"},\"toggleTrusted(address,uint8)\":{\"notice\":\"Changes the trusted status for `sender` when for selling rewards or updating the normalizer\"},\"updateOracle(address)\":{\"notice\":\"Update oracle data for a given `collateral`\"},\"updatePayees(address[],uint256[],bool)\":{\"notice\":\"Updates the payees and their shares\"},\"updateSlippageTolerance(address,uint256)\":{\"notice\":\"Updates the slippage tolerance for a `collateral`\"},\"updateSurplusBufferRatio(uint64)\":{\"notice\":\"Updates the surplus buffer ratio\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/SettersGovernor.sol\":\"SettersGovernor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xd4d195b62841c28dd5f248d09e682c3c81bda24b471cd8a5d8efe498519ea50d\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n}\\n\",\"keccak256\":\"0xaa7d137a74a6f51760acf46ff2ef777de831422d2fd8282ec683ac806af0ca3a\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/SettersGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { ISettersGovernor } from \\\"contracts/interfaces/ISetters.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibSetters } from \\\"../libraries/LibSetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title SettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\\ncontract SettersGovernor is AccessManagedModifiers, ISettersGovernor {\\n  using SafeERC20 for IERC20;\\n\\n  event Recovered(address indexed token, address indexed to, uint256 amount);\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev No check is made on the collateral that is redeemed: this function could typically be used by a\\n  /// governance during a manual rebalance of the reserves of the system\\n  /// @dev `collateral` is different from `token` only in the case of a managed collateral\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);\\n    else token.safeTransfer(to, amount);\\n    emit Recovered(address(token), to, amount);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setAccessManager(address _newAccessManager) external restricted {\\n    LibSetters.setAccessManager(IAccessManager(_newAccessManager));\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the\\n  /// funds associated to the collateral it corresponds to\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {\\n    uint256 currentAllowance = token.allowance(address(this), spender);\\n    if (currentAllowance < amount) {\\n      token.safeIncreaseAllowance(spender, amount - currentAllowance);\\n    } else if (currentAllowance > amount) {\\n      token.safeDecreaseAllowance(spender, currentAllowance - amount);\\n    }\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function toggleTrusted(address sender, TrustedType t) external restricted {\\n    LibSetters.toggleTrusted(sender, t);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Collateral assets with a fee on transfer are not supported by the system\\n  function addCollateral(address collateral) external restricted {\\n    LibSetters.addCollateral(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev The amount passed here must be an absolute amount\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {\\n    LibSetters.adjustStablecoins(collateral, amount, increase);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral\\n  /// is not used to back stables\\n  /// @dev The system may still have a non null balance of the collateral that is revoked: this should later\\n  /// be handled through a recoverERC20 call\\n  /// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is\\n  /// true\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {\\n    LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setOracle(address collateral, bytes memory oracleConfig) external restricted {\\n    LibSetters.setOracle(collateral, oracleConfig);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateOracle(address collateral) external {\\n    if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    LibOracle.updateOracle(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setWhitelistStatus(\\n    address collateral,\\n    uint8 whitelistStatus,\\n    bytes memory whitelistData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external restricted {\\n    LibSetters.updatePayees(_payees, _shares, _skipRelease);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external restricted {\\n    LibSetters.updateSlippageTolerance(collateral, slippageTolerance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {\\n    LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);\\n  }\\n}\\n\",\"keccak256\":\"0x3d0d0351ef8f06a401c421d2f76b4227e4819935583ad29f44fc6dc59f5ea021\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    if (oracleValue > maxValue) {\\n      ts.collaterals[collateral].oracleConfig = abi.encode(\\n        oracleType,\\n        targetType,\\n        oracleData,\\n        // There are no checks whether the value increased or not\\n        abi.encode(oracleValue),\\n        hyperparameters\\n      );\\n    } else {\\n      revert OracleUpdateFailed();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x068d08d7c0fcc337b07f96ace963fd7c56d5e2a33fd1ce99ba05f2216b97daac\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport { LibSurplus } from \\\"./LibSurplus.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { LibDiamond } from \\\"./LibDiamond.sol\\\";\\nimport { LibWhitelist } from \\\"./LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibSetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibSetters.sol\\nlibrary LibSetters {\\n  using SafeCast for uint256;\\n\\n  event CollateralAdded(address indexed collateral);\\n  event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);\\n  event CollateralRevoked(address indexed collateral);\\n  event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);\\n  event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);\\n  event OracleSet(address indexed collateral, bytes oracleConfig);\\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n  event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);\\n  event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);\\n  event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);\\n  event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);\\n  event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);\\n  event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);\\n  event PayeeAdded(address indexed payee, uint256 shares);\\n  event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);\\n  event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GOVERNOR ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `setAccessManager`\\n  function setAccessManager(IAccessManager _newAccessManager) internal {\\n    if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();\\n    DiamondStorage storage ds = s.diamondStorage();\\n    address previousAccessManager = address(ds.accessManager);\\n    ds.accessManager = _newAccessManager;\\n    emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));\\n  }\\n\\n  /// @notice Internal version of `setCollateralManager`\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    internal\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    if (managerData.config.length != 0) {\\n      // The first subCollateral given should be the actual collateral asset\\n      if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();\\n      // Sanity check on the manager data that is passed\\n      LibManager.parseManagerConfig(managerData.config);\\n      collatInfo.isManaged = 1;\\n    } else {\\n      collatInfo.isManaged = 0;\\n    }\\n    collatInfo.managerData = managerData;\\n    emit CollateralManagerSet(collateral, managerData);\\n  }\\n\\n  /// @notice Internal version of `toggleTrusted`\\n  function toggleTrusted(address sender, TrustedType t) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 trustedStatus;\\n    if (t == TrustedType.Updater) {\\n      trustedStatus = 1 - ts.isTrusted[sender];\\n      ts.isTrusted[sender] = trustedStatus;\\n    } else {\\n      trustedStatus = 1 - ts.isSellerTrusted[sender];\\n      ts.isSellerTrusted[sender] = trustedStatus;\\n    }\\n    emit TrustedToggled(sender, trustedStatus == 1, t);\\n  }\\n\\n  /// @notice Internal version of `addCollateral`\\n  function addCollateral(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals != 0) revert AlreadyAdded();\\n    collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());\\n    ts.collateralList.push(collateral);\\n    emit CollateralAdded(collateral);\\n  }\\n\\n  /// @notice Internal version of `adjustStablecoins`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();\\n    if (increase) {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables + normalizedAmount;\\n      if (uint256(collatInfo.normalizedStables) * uint256(ts.normalizer) / BASE_27 > collatInfo.stablecoinCap) {\\n        revert AboveCap();\\n      }\\n    } else {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables - normalizedAmount;\\n    }\\n    emit ReservesAdjusted(collateral, amount, increase);\\n  }\\n\\n  /// @notice Internal version of `revokeCollateral`\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (collatInfo.normalizedStables > 0) revert CollateralBacked();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    delete ts.collaterals[collateral];\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 length = collateralListMem.length;\\n    for (uint256 i; i < length - 1; ++i) {\\n      if (collateralListMem[i] == collateral) {\\n        ts.collateralList[i] = collateralListMem[length - 1];\\n        break;\\n      }\\n    }\\n    ts.collateralList.pop();\\n    emit CollateralRevoked(collateral);\\n  }\\n\\n  /// @notice Internal version of `setOracle`\\n  function setOracle(address collateral, bytes memory oracleConfig) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    (,,,, bytes memory hyperparameters) =\\n      abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    if (userDeviation > burnRatioDeviation) revert InvalidParams();\\n    // Checks oracle validity\\n    LibOracle.readMint(oracleConfig);\\n    collatInfo.oracleConfig = oracleConfig;\\n    emit OracleSet(collateral, oracleConfig);\\n  }\\n\\n  /// @notice Internal version of `setWhitelistStatus`\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {\\n    if (whitelistStatus > 1) revert InvalidWhitelistStatus();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (whitelistStatus == 1) {\\n      // Sanity check\\n      LibWhitelist.checkWhitelist(whitelistData, address(this));\\n      collatInfo.whitelistData = whitelistData;\\n    } else {\\n      // If whitelist is revoked, clear the whitelist data\\n      collatInfo.whitelistData = \\\"\\\";\\n    }\\n    collatInfo.onlyWhitelisted = whitelistStatus;\\n    emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GUARDIAN ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `pause` \\u2014 sets the action's live flag to `0`\\n  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance\\n  /// call cannot pass silently\\n  function pause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 0);\\n  }\\n\\n  /// @notice Internal version of `unpause` \\u2014 sets the action's live flag to `1`\\n  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance\\n  /// call cannot pass silently\\n  function unpause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 1);\\n  }\\n\\n  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`\\n  /// to unpause. Reverts on no-op transitions.\\n  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;\\n      if (currentIsLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      if (action == ActionType.Mint) {\\n        collatInfo.isMintLive = targetIsLive;\\n      } else {\\n        collatInfo.isBurnLive = targetIsLive;\\n      }\\n    } else {\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      if (ts.isRedemptionLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      ts.isRedemptionLive = targetIsLive;\\n    }\\n    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);\\n  }\\n\\n  /// @notice Internal version of `setFees`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);\\n    if (mint) {\\n      collatInfo.xFeeMint = xFee;\\n      collatInfo.yFeeMint = yFee;\\n    } else {\\n      collatInfo.xFeeBurn = xFee;\\n      collatInfo.yFeeBurn = yFee;\\n    }\\n    emit FeesSet(collateral, xFee, yFee, mint);\\n  }\\n\\n  /// @notice Internal version of `setRedemptionCurveParams`\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    LibSetters.checkFees(xFee, yFee, ActionType.Redeem);\\n    ts.xRedemptionCurve = xFee;\\n    ts.yRedemptionCurve = yFee;\\n    emit RedemptionCurveParamsSet(xFee, yFee);\\n  }\\n\\n  /// @notice Internal version of `toggleWhitelist`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];\\n    ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;\\n    emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);\\n  }\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a collateral\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    collatInfo.stablecoinCap = stablecoinCap;\\n    emit StablecoinCapSet(collateral, stablecoinCap);\\n  }\\n\\n  /// @notice Internal version of `updatePayees`\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) internal {\\n    if (_payees.length == 0 || _payees.length > MAX_PAYEES) revert InvalidLengths();\\n    if (_payees.length != _shares.length) revert ArrayLengthMismatch();\\n    /// @dev Distribute the fees before updating the fee receivers.\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!_skipRelease) {\\n      uint256 income = ts.tokenP.balanceOf(address(this));\\n      if (income > 0 && ts.payees.length > 0) {\\n        LibSurplus.release(income, ts.payees);\\n      }\\n    }\\n\\n    // Zero out stale shares for old payees\\n    uint256 i = 0;\\n    for (; i < ts.payees.length; ++i) {\\n      ts.shares[ts.payees[i]] = 0;\\n    }\\n    delete ts.payees;\\n    uint256 _totalShares = 0;\\n    i = 0;\\n    for (; i < _payees.length; ++i) {\\n      for (uint256 j = 0; j < i; ++j) {\\n        if (_payees[j] == _payees[i]) revert AlreadyAdded();\\n      }\\n      _totalShares += _addPayee(_payees[i], _shares[i]);\\n    }\\n    ts.totalShares = _totalShares;\\n  }\\n\\n  /// @notice Internal version of `updateSlippageTolerance`\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) internal {\\n    if (slippageTolerance > BASE_9) revert InvalidRate();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.slippageTolerance[collateral] = slippageTolerance;\\n    emit SlippageToleranceUpdated(collateral, slippageTolerance);\\n  }\\n\\n  /// @notice Internal version of `updateSurplusBufferRatio`\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {\\n    if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.surplusBufferRatio = _surplusBufferRatio;\\n    emit SurplusBufferRatioUpdated(_surplusBufferRatio);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions\\n  function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {\\n    uint256 n = xFee.length;\\n    if (n != yFee.length || n == 0) revert InvalidParams();\\n    if (\\n      // Mint inflexion points should be in [0,BASE_9[\\n      // We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9\\n      // Hence we consider BASE_12 as the max value (100% fees) for yFeeMint\\n      // Burn inflexion points should be in [0,BASE_9] but fees should be constant in\\n      // the first segment [BASE_9, x_{n-1}[\\n      // Redemption inflexion points should be in [0,BASE_9]\\n      (action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))\\n        || (action == ActionType.Burn\\n          && (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1]))))\\n        || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))\\n    ) {\\n      revert InvalidParams();\\n    }\\n\\n    for (uint256 i; i < n - 1; ++i) {\\n      if (\\n        // xFee strictly increasing and yFee increasing for mints\\n        // xFee strictly decreasing and yFee increasing for burns\\n        // xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions\\n        (action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))\\n      ) revert InvalidParams();\\n    }\\n\\n    // If a mint or burn fee is negative, we need to check that accounts atomically minting\\n    // (from any collateral) and then burning cannot get more than their initial value\\n    if (yFee[0] < 0) {\\n      if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 length = collateralListMem.length;\\n      if (action == ActionType.Mint) {\\n        // This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;\\n          if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n      if (action == ActionType.Burn) {\\n        // This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;\\n          if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n    }\\n  }\\n\\n  /// @notice Add a new fee receiver.\\n  /// @param _payee The address of the fee receiver.\\n  /// @param _shares The number of shares assigned to the fee receiver.\\n  function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {\\n    if (_shares == 0) revert ZeroAmount();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n\\n    ts.payees.push(_payee);\\n    ts.shares[_payee] = _shares;\\n    emit PayeeAdded(_payee, _shares);\\n    return _shares;\\n  }\\n}\\n\",\"keccak256\":\"0x9e41915e7fb03ef3b054f7ce0b7ab297e3b8f5c05ab1e7ebe072e22f11b22362\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS                                                  \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES                                                 \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\naddress constant ODOS_ROUTER = 0xCf5540fFFCdC3d510B18bFcA6d2b9987b0772559;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x2beca19c6b45c5507a141f5ba0b5952e72480920220d46b673885bb088bf6ca0\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror OdosSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xa9abc94129bd5e0964585da120facf621e1edd31fcb234fe677d4e050a728f4d\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
+  "metadata": "{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"AboveCap\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"caller\",\"type\":\"address\"}],\"name\":\"AccessManagedUnauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyAdded\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ArrayLengthMismatch\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"CollateralBacked\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidAccessManager\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidChainlinkRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParam\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidParams\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidPayee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidRate\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidWhitelistStatus\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ManagerHasAssets\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotCollateral\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NotTrusted\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OracleUpdateFailed\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint8\",\"name\":\"bits\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"SafeCastOverflowedUintDowncast\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"currentAllowance\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"requestedDecrease\",\"type\":\"uint256\"}],\"name\":\"SafeERC20FailedDecreaseAllowance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAmount\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"indexed\":false,\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"CollateralManagerSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"CollateralRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"}],\"name\":\"CollateralWhitelistStatusUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleased\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"income\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"releasedAt\",\"type\":\"uint256\"}],\"name\":\"IncomeReleasedToPayee\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"OracleSet\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"previousTarget\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newTarget\",\"type\":\"uint256\"}],\"name\":\"OracleTargetUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"payee\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"PayeeAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"ReservesAdjusted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"SlippageToleranceUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"SurplusBufferRatioUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"swapRouter\",\"type\":\"address\"}],\"name\":\"SwapRouterUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isTrusted\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"enum TrustedType\",\"name\":\"trustedType\",\"type\":\"uint8\"}],\"name\":\"TrustedToggled\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"addCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"increase\",\"type\":\"bool\"}],\"name\":\"adjustStablecoins\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"changeAllowance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"}],\"name\":\"revokeCollateral\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_newAccessManager\",\"type\":\"address\"}],\"name\":\"setAccessManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"checkExternalManagerBalance\",\"type\":\"bool\"},{\"components\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"subCollaterals\",\"type\":\"address[]\"},{\"internalType\":\"bytes\",\"name\":\"config\",\"type\":\"bytes\"}],\"internalType\":\"struct ManagerStorage\",\"name\":\"managerData\",\"type\":\"tuple\"}],\"name\":\"setCollateralManager\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"oracleConfig\",\"type\":\"bytes\"}],\"name\":\"setOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"swapRouter\",\"type\":\"address\"}],\"name\":\"setSwapRouter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint8\",\"name\":\"whitelistStatus\",\"type\":\"uint8\"},{\"internalType\":\"bytes\",\"name\":\"whitelistData\",\"type\":\"bytes\"}],\"name\":\"setWhitelistStatus\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"enum TrustedType\",\"name\":\"t\",\"type\":\"uint8\"}],\"name\":\"toggleTrusted\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"}],\"name\":\"updateOracle\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_payees\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_shares\",\"type\":\"uint256[]\"},{\"internalType\":\"bool\",\"name\":\"_skipRelease\",\"type\":\"bool\"}],\"name\":\"updatePayees\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"collateral\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"slippageTolerance\",\"type\":\"uint256\"}],\"name\":\"updateSlippageTolerance\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_surplusBufferRatio\",\"type\":\"uint64\"}],\"name\":\"updateSurplusBufferRatio\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"author\":\"Cooper Labs\",\"custom:contact\":\"security@cooperlabs.xyz\",\"details\":\"This contract is an authorized fork of Angle's `SettersGovernor` contract https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\",\"errors\":{\"SafeCastOverflowedUintDowncast(uint8,uint256)\":[{\"details\":\"Value doesn't fit in an uint of `bits` size.\"}],\"SafeERC20FailedDecreaseAllowance(address,uint256,uint256)\":[{\"details\":\"Indicates a failed `decreaseAllowance` request.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"addCollateral(address)\":{\"details\":\"Collateral assets with a fee on transfer are not supported by the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"details\":\"The amount passed here must be an absolute amount\"},\"changeAllowance(address,address,uint256)\":{\"details\":\"This function can typically be used to grant allowance to a newly added manager for it to pull the funds associated to the collateral it corresponds to\"},\"recoverERC20(address,address,address,uint256)\":{\"details\":\"No check is made on the collateral that is redeemed: this function could typically be used by a governance during a manual rebalance of the reserves of the system`collateral` is different from `token` only in the case of a managed collateral\"},\"revokeCollateral(address,bool)\":{\"details\":\"Require `collatInfo.normalizedStables == 0`, that is to say that the collateral is not used to back stablesThe system may still have a non null balance of the collateral that is revoked: this should later be handled through a recoverERC20 callFunds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is true\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"details\":\"Funds need to have been withdrawn from the eventual previous manager prior to this call\"},\"setSwapRouter(address)\":{\"details\":\"The payload is executed with a raw call, so any router can be configured. It is chain specific and must be set on every deployment before rewards can be sold\"},\"updatePayees(address[],uint256[],bool)\":{\"params\":{\"_payees\":\"The new payee addresses\",\"_shares\":\"The new shares for each payee\",\"_skipRelease\":\"If true, skips the automatic income release before updating\"}},\"updateSlippageTolerance(address,uint256)\":{\"details\":\"Maximum slippage tolerance is 1e9 (100%)The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when calling the `processSurplus` function\"},\"updateSurplusBufferRatio(uint64)\":{\"details\":\"The surplus buffer ratio is the minimum collateral ratio required after surplus processing\",\"params\":{\"_surplusBufferRatio\":\"The new surplus buffer ratio in BASE_9\"}}},\"title\":\"SettersGovernor\",\"version\":1},\"userdoc\":{\"events\":{\"OracleTargetUpdated(address,uint256,uint256)\":{\"notice\":\"Emitted when a MAX target price is ratcheted up by `updateOracle`\"}},\"kind\":\"user\",\"methods\":{\"addCollateral(address)\":{\"notice\":\"Add `collateral` as a supported collateral in the system\"},\"adjustStablecoins(address,uint128,bool)\":{\"notice\":\"Adjusts the amount of stablecoins issued from `collateral` by `amount`\"},\"changeAllowance(address,address,uint256)\":{\"notice\":\"Sets the allowance of the contract on `token` for `spender` to `amount`\"},\"recoverERC20(address,address,address,uint256)\":{\"notice\":\"Recovers `amount` of `token` from the Parallelizer contract\"},\"revokeCollateral(address,bool)\":{\"notice\":\"Revokes `collateral` from the system\"},\"setAccessManager(address)\":{\"notice\":\"Sets a new access manager address\"},\"setCollateralManager(address,bool,(address[],bytes))\":{\"notice\":\"Sets (or unsets) a collateral manager  `collateral`\"},\"setOracle(address,bytes)\":{\"notice\":\"Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations\"},\"setSwapRouter(address)\":{\"notice\":\"Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\"},\"setWhitelistStatus(address,uint8,bytes)\":{\"notice\":\"Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist\"},\"toggleTrusted(address,uint8)\":{\"notice\":\"Changes the trusted status for `sender` when for selling rewards or updating the normalizer\"},\"updateOracle(address)\":{\"notice\":\"Update oracle data for a given `collateral`\"},\"updatePayees(address[],uint256[],bool)\":{\"notice\":\"Updates the payees and their shares\"},\"updateSlippageTolerance(address,uint256)\":{\"notice\":\"Updates the slippage tolerance for a `collateral`\"},\"updateSurplusBufferRatio(uint64)\":{\"notice\":\"Updates the surplus buffer ratio\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"project/contracts/parallelizer/facets/SettersGovernor.sol\":\"SettersGovernor\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000},\"remappings\":[\"npm/@openzeppelin/contracts-upgradeable@5.4.0/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:@helpers/=project/libs/helpers/\",\"project/:@openzeppelin/contracts-upgradeable/=npm/@openzeppelin/contracts-upgradeable@5.4.0/\",\"project/:@openzeppelin/contracts/=npm/@openzeppelin/contracts@5.4.0/\",\"project/:contracts/=project/contracts/\"]},\"sources\":{\"npm/@openzeppelin/contracts@5.4.0/access/manager/AuthorityUtils.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IAuthority} from \\\"./IAuthority.sol\\\";\\n\\nlibrary AuthorityUtils {\\n    /**\\n     * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility\\n     * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.\\n     * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.\\n     */\\n    function canCallWithDelay(\\n        address authority,\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) internal view returns (bool immediate, uint32 delay) {\\n        bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector));\\n\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x00)\\n            mstore(0x20, 0x00)\\n\\n            if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) {\\n                immediate := mload(0x00)\\n                delay := mload(0x20)\\n\\n                // If delay does not fit in a uint32, return 0 (no delay)\\n                // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 }\\n                delay := mul(delay, iszero(shr(32, delay)))\\n            }\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x05fd06ae5bca9dc7470fb2dfae764315c81a84f591e86be6fec0c115474edc6c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAccessManager.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)\\n\\npragma solidity >=0.8.4;\\n\\ninterface IAccessManager {\\n    /**\\n     * @dev A delayed operation was scheduled.\\n     */\\n    event OperationScheduled(\\n        bytes32 indexed operationId,\\n        uint32 indexed nonce,\\n        uint48 schedule,\\n        address caller,\\n        address target,\\n        bytes data\\n    );\\n\\n    /**\\n     * @dev A scheduled operation was executed.\\n     */\\n    event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev A scheduled operation was canceled.\\n     */\\n    event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);\\n\\n    /**\\n     * @dev Informational labelling for a roleId.\\n     */\\n    event RoleLabel(uint64 indexed roleId, string label);\\n\\n    /**\\n     * @dev Emitted when `account` is granted `roleId`.\\n     *\\n     * NOTE: The meaning of the `since` argument depends on the `newMember` argument.\\n     * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,\\n     * otherwise it indicates the execution delay for this account and roleId is updated.\\n     */\\n    event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);\\n\\n    /**\\n     * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.\\n     */\\n    event RoleRevoked(uint64 indexed roleId, address indexed account);\\n\\n    /**\\n     * @dev Role acting as admin over a given `roleId` is updated.\\n     */\\n    event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);\\n\\n    /**\\n     * @dev Role acting as guardian over a given `roleId` is updated.\\n     */\\n    event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);\\n\\n    /**\\n     * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.\\n     */\\n    event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);\\n\\n    /**\\n     * @dev Target mode is updated (true = closed, false = open).\\n     */\\n    event TargetClosed(address indexed target, bool closed);\\n\\n    /**\\n     * @dev Role required to invoke `selector` on `target` is updated to `roleId`.\\n     */\\n    event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);\\n\\n    /**\\n     * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.\\n     */\\n    event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);\\n\\n    error AccessManagerAlreadyScheduled(bytes32 operationId);\\n    error AccessManagerNotScheduled(bytes32 operationId);\\n    error AccessManagerNotReady(bytes32 operationId);\\n    error AccessManagerExpired(bytes32 operationId);\\n    error AccessManagerLockedRole(uint64 roleId);\\n    error AccessManagerBadConfirmation();\\n    error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);\\n    error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);\\n    error AccessManagerUnauthorizedConsume(address target);\\n    error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);\\n    error AccessManagerInvalidInitialAdmin(address initialAdmin);\\n\\n    /**\\n     * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with\\n     * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}\\n     * & {execute} workflow.\\n     *\\n     * This function is usually called by the targeted contract to control immediate execution of restricted functions.\\n     * Therefore we only return true if the call can be performed without any delay. If the call is subject to a\\n     * previously set delay (not zero), then the function should return false and the caller should schedule the operation\\n     * for future execution.\\n     *\\n     * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise\\n     * the operation can be executed if and only if delay is greater than 0.\\n     *\\n     * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that\\n     * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail\\n     * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.\\n     *\\n     * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the\\n     * {AccessManager} documentation.\\n     */\\n    function canCall(\\n        address caller,\\n        address target,\\n        bytes4 selector\\n    ) external view returns (bool allowed, uint32 delay);\\n\\n    /**\\n     * @dev Expiration delay for scheduled proposals. Defaults to 1 week.\\n     *\\n     * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,\\n     * disabling any scheduling usage.\\n     */\\n    function expiration() external view returns (uint32);\\n\\n    /**\\n     * @dev Minimum setback for all delay updates, with the exception of execution delays. It\\n     * can be increased without setback (and reset via {revokeRole} in the case event of an\\n     * accidental increase). Defaults to 5 days.\\n     */\\n    function minSetback() external view returns (uint32);\\n\\n    /**\\n     * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.\\n     *\\n     * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.\\n     */\\n    function isTargetClosed(address target) external view returns (bool);\\n\\n    /**\\n     * @dev Get the role required to call a function.\\n     */\\n    function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.\\n     */\\n    function getTargetAdminDelay(address target) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the id of the role that acts as an admin for the given role.\\n     *\\n     * The admin permission is required to grant the role, revoke the role and update the execution delay to execute\\n     * an operation that is restricted to this role.\\n     */\\n    function getRoleAdmin(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role that acts as a guardian for a given role.\\n     *\\n     * The guardian permission allows canceling operations that have been scheduled under the role.\\n     */\\n    function getRoleGuardian(uint64 roleId) external view returns (uint64);\\n\\n    /**\\n     * @dev Get the role current grant delay.\\n     *\\n     * Its value may change at any point without an event emitted following a call to {setGrantDelay}.\\n     * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.\\n     */\\n    function getRoleGrantDelay(uint64 roleId) external view returns (uint32);\\n\\n    /**\\n     * @dev Get the access details for a given account for a given role. These details include the timepoint at which\\n     * membership becomes active, and the delay applied to all operation by this user that requires this permission\\n     * level.\\n     *\\n     * Returns:\\n     * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.\\n     * [1] Current execution delay for the account.\\n     * [2] Pending execution delay for the account.\\n     * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.\\n     */\\n    function getAccess(\\n        uint64 roleId,\\n        address account\\n    ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);\\n\\n    /**\\n     * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this\\n     * permission might be associated with an execution delay. {getAccess} can provide more details.\\n     */\\n    function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);\\n\\n    /**\\n     * @dev Give a label to a role, for improved role discoverability by UIs.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleLabel} event.\\n     */\\n    function labelRole(uint64 roleId, string calldata label) external;\\n\\n    /**\\n     * @dev Add `account` to `roleId`, or change its execution delay.\\n     *\\n     * This gives the account the authorization to call any function that is restricted to this role. An optional\\n     * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation\\n     * that is restricted to members of this role. The user will only be able to execute the operation after the delay has\\n     * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).\\n     *\\n     * If the account has already been granted this role, the execution delay will be updated. This update is not\\n     * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is\\n     * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any\\n     * operation executed in the 3 hours that follows this update was indeed scheduled before this update.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - granted role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleGranted} event.\\n     */\\n    function grantRole(uint64 roleId, address account, uint32 executionDelay) external;\\n\\n    /**\\n     * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has\\n     * no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be an admin for the role (see {getRoleAdmin})\\n     * - revoked role must not be the `PUBLIC_ROLE`\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function revokeRole(uint64 roleId, address account) external;\\n\\n    /**\\n     * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in\\n     * the role this call has no effect.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be `callerConfirmation`.\\n     *\\n     * Emits a {RoleRevoked} event if the account had the role.\\n     */\\n    function renounceRole(uint64 roleId, address callerConfirmation) external;\\n\\n    /**\\n     * @dev Change admin role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleAdminChanged} event\\n     */\\n    function setRoleAdmin(uint64 roleId, uint64 admin) external;\\n\\n    /**\\n     * @dev Change guardian role for a given role.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGuardianChanged} event\\n     */\\n    function setRoleGuardian(uint64 roleId, uint64 guardian) external;\\n\\n    /**\\n     * @dev Update the delay for granting a `roleId`.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {RoleGrantDelayChanged} event.\\n     */\\n    function setGrantDelay(uint64 roleId, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetFunctionRoleUpdated} event per selector.\\n     */\\n    function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;\\n\\n    /**\\n     * @dev Set the delay for changing the configuration of a given target contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetAdminDelayUpdated} event.\\n     */\\n    function setTargetAdminDelay(address target, uint32 newDelay) external;\\n\\n    /**\\n     * @dev Set the closed flag for a contract.\\n     *\\n     * Closing the manager itself won't disable access to admin methods to avoid locking the contract.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     *\\n     * Emits a {TargetClosed} event.\\n     */\\n    function setTargetClosed(address target, bool closed) external;\\n\\n    /**\\n     * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the\\n     * operation is not yet scheduled, has expired, was executed, or was canceled.\\n     */\\n    function getSchedule(bytes32 id) external view returns (uint48);\\n\\n    /**\\n     * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never\\n     * been scheduled.\\n     */\\n    function getNonce(bytes32 id) external view returns (uint32);\\n\\n    /**\\n     * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to\\n     * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays\\n     * required for the caller. The special value zero will automatically set the earliest possible time.\\n     *\\n     * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when\\n     * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this\\n     * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.\\n     *\\n     * Emits a {OperationScheduled} event.\\n     *\\n     * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If\\n     * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target\\n     * contract if it is using standard Solidity ABI encoding.\\n     */\\n    function schedule(\\n        address target,\\n        bytes calldata data,\\n        uint48 when\\n    ) external returns (bytes32 operationId, uint32 nonce);\\n\\n    /**\\n     * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the\\n     * execution delay is 0.\\n     *\\n     * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the\\n     * operation wasn't previously scheduled (if the caller doesn't have an execution delay).\\n     *\\n     * Emits an {OperationExecuted} event only if the call was scheduled and delayed.\\n     */\\n    function execute(address target, bytes calldata data) external payable returns (uint32);\\n\\n    /**\\n     * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled\\n     * operation that is cancelled.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be the proposer, a guardian of the targeted function, or a global admin\\n     *\\n     * Emits a {OperationCanceled} event.\\n     */\\n    function cancel(address caller, address target, bytes calldata data) external returns (uint32);\\n\\n    /**\\n     * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed\\n     * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.\\n     *\\n     * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,\\n     * with all the verifications that it implies.\\n     *\\n     * Emit a {OperationExecuted} event.\\n     */\\n    function consumeScheduledOp(address caller, bytes calldata data) external;\\n\\n    /**\\n     * @dev Hashing function for delayed operations.\\n     */\\n    function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);\\n\\n    /**\\n     * @dev Changes the authority of a target managed by this manager instance.\\n     *\\n     * Requirements:\\n     *\\n     * - the caller must be a global admin\\n     */\\n    function updateAuthority(address target, address newAuthority) external;\\n}\\n\",\"keccak256\":\"0x640fe2b6e5201c47322d458f81078d6dcf23ccf9954f8995b1b7bfbec0eb1421\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/access/manager/IAuthority.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Standard interface for permissioning originally defined in Dappsys.\\n */\\ninterface IAuthority {\\n    /**\\n     * @dev Returns true if the caller can invoke on a target the function identified by a function selector.\\n     */\\n    function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);\\n}\\n\",\"keccak256\":\"0x9c9a58dd831b9bb4a0ea47d96b53c13ab9a6e4270a518ea395b1424092fd74dc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC1363.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"./IERC20.sol\\\";\\nimport {IERC165} from \\\"./IERC165.sol\\\";\\n\\n/**\\n * @title IERC1363\\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\\n *\\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\\n */\\ninterface IERC1363 is IERC20, IERC165 {\\n    /*\\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\\n     * 0xb0202a11 ===\\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\\n     */\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\\n     * @param from The address which you want to send tokens from.\\n     * @param to The address which you want to transfer to.\\n     * @param value The amount of tokens to be transferred.\\n     * @param data Additional data with no specified format, sent in call to `to`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\\n     * @param spender The address which will spend the funds.\\n     * @param value The amount of tokens to be spent.\\n     * @param data Additional data with no specified format, sent in call to `spender`.\\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\\n     */\\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\\n}\\n\",\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC165} from \\\"../utils/introspection/IERC165.sol\\\";\\n\",\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/interfaces/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\nimport {IERC20} from \\\"../token/ERC20/IERC20.sol\\\";\\n\",\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-20 standard as defined in the ERC.\\n */\\ninterface IERC20 {\\n    /**\\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n     * another (`to`).\\n     *\\n     * Note that `value` may be zero.\\n     */\\n    event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n    /**\\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n     * a call to {approve}. `value` is the new allowance.\\n     */\\n    event Approval(address indexed owner, address indexed spender, uint256 value);\\n\\n    /**\\n     * @dev Returns the value of tokens in existence.\\n     */\\n    function totalSupply() external view returns (uint256);\\n\\n    /**\\n     * @dev Returns the value of tokens owned by `account`.\\n     */\\n    function balanceOf(address account) external view returns (uint256);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transfer(address to, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Returns the remaining number of tokens that `spender` will be\\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n     * zero by default.\\n     *\\n     * This value changes when {approve} or {transferFrom} are called.\\n     */\\n    function allowance(address owner, address spender) external view returns (uint256);\\n\\n    /**\\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\\n     * caller's tokens.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n     * that someone may use both the old and the new allowance by unfortunate\\n     * transaction ordering. One possible solution to mitigate this race\\n     * condition is to first reduce the spender's allowance to 0 and set the\\n     * desired value afterwards:\\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n     *\\n     * Emits an {Approval} event.\\n     */\\n    function approve(address spender, uint256 value) external returns (bool);\\n\\n    /**\\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\\n     * allowance mechanism. `value` is then deducted from the caller's\\n     * allowance.\\n     *\\n     * Returns a boolean value indicating whether the operation succeeded.\\n     *\\n     * Emits a {Transfer} event.\\n     */\\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\\n}\\n\",\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/extensions/IERC20Metadata.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)\\n\\npragma solidity >=0.6.2;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\n\\n/**\\n * @dev Interface for the optional metadata functions from the ERC-20 standard.\\n */\\ninterface IERC20Metadata is IERC20 {\\n    /**\\n     * @dev Returns the name of the token.\\n     */\\n    function name() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the symbol of the token.\\n     */\\n    function symbol() external view returns (string memory);\\n\\n    /**\\n     * @dev Returns the decimals places of the token.\\n     */\\n    function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0xd6fa4088198f04eef10c5bce8a2f4d60554b7ec4b987f684393c01bf79b94d9f\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/token/ERC20/utils/SafeERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {IERC20} from \\\"../IERC20.sol\\\";\\nimport {IERC1363} from \\\"../../../interfaces/IERC1363.sol\\\";\\n\\n/**\\n * @title SafeERC20\\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\\n * contract returns false). Tokens that return no value (and instead revert or\\n * throw on failure) are also supported, non-reverting calls are assumed to be\\n * successful.\\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\\n */\\nlibrary SafeERC20 {\\n    /**\\n     * @dev An operation with an ERC-20 token failed.\\n     */\\n    error SafeERC20FailedOperation(address token);\\n\\n    /**\\n     * @dev Indicates a failed `decreaseAllowance` request.\\n     */\\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\\n     */\\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\\n        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));\\n    }\\n\\n    /**\\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\\n     */\\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\\n        return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value)));\\n    }\\n\\n    /**\\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\\n        uint256 oldAllowance = token.allowance(address(this), spender);\\n        forceApprove(token, spender, oldAllowance + value);\\n    }\\n\\n    /**\\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\\n     * value, non-reverting calls are assumed to be successful.\\n     *\\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \\\"client\\\"\\n     * smart contract uses ERC-7674 to set temporary allowances, then the \\\"client\\\" smart contract should avoid using\\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\\n     */\\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\\n        unchecked {\\n            uint256 currentAllowance = token.allowance(address(this), spender);\\n            if (currentAllowance < requestedDecrease) {\\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\\n            }\\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\\n        }\\n    }\\n\\n    /**\\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\\n     * to be set to zero before setting it to a non-zero value, such as USDT.\\n     *\\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\\n     * only sets the \\\"standard\\\" allowance. Any temporary allowance will remain active, in addition to the value being\\n     * set here.\\n     */\\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\\n        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));\\n\\n        if (!_callOptionalReturnBool(token, approvalCall)) {\\n            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));\\n            _callOptionalReturn(token, approvalCall);\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            safeTransfer(token, to, value);\\n        } else if (!token.transferAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function transferFromAndCallRelaxed(\\n        IERC1363 token,\\n        address from,\\n        address to,\\n        uint256 value,\\n        bytes memory data\\n    ) internal {\\n        if (to.code.length == 0) {\\n            safeTransferFrom(token, from, to, value);\\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\\n     * targeting contracts.\\n     *\\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\\n     * once without retrying, and relies on the returned value to be true.\\n     *\\n     * Reverts if the returned value is other than `true`.\\n     */\\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\\n        if (to.code.length == 0) {\\n            forceApprove(token, to, value);\\n        } else if (!token.approveAndCall(to, value, data)) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturnBool} that reverts if call fails to meet the requirements.\\n     */\\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            // bubble errors\\n            if iszero(success) {\\n                let ptr := mload(0x40)\\n                returndatacopy(ptr, 0, returndatasize())\\n                revert(ptr, returndatasize())\\n            }\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n\\n        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {\\n            revert SafeERC20FailedOperation(address(token));\\n        }\\n    }\\n\\n    /**\\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\\n     * @param token The token targeted by the call.\\n     * @param data The call data (encoded using abi.encode or one of its variants).\\n     *\\n     * This is a variant of {_callOptionalReturn} that silently catches all reverts and returns a bool instead.\\n     */\\n    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {\\n        bool success;\\n        uint256 returnSize;\\n        uint256 returnValue;\\n        assembly (\\\"memory-safe\\\") {\\n            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)\\n            returnSize := returndatasize()\\n            returnValue := mload(0)\\n        }\\n        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);\\n    }\\n}\\n\",\"keccak256\":\"0x982c5cb790ab941d1e04f807120a71709d4c313ba0bfc16006447ffbd27fbbd5\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/Panic.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Helper library for emitting standardized panic codes.\\n *\\n * ```solidity\\n * contract Example {\\n *      using Panic for uint256;\\n *\\n *      // Use any of the declared internal constants\\n *      function foo() { Panic.GENERIC.panic(); }\\n *\\n *      // Alternatively\\n *      function foo() { Panic.panic(Panic.GENERIC); }\\n * }\\n * ```\\n *\\n * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].\\n *\\n * _Available since v5.1._\\n */\\n// slither-disable-next-line unused-state\\nlibrary Panic {\\n    /// @dev generic / unspecified error\\n    uint256 internal constant GENERIC = 0x00;\\n    /// @dev used by the assert() builtin\\n    uint256 internal constant ASSERT = 0x01;\\n    /// @dev arithmetic underflow or overflow\\n    uint256 internal constant UNDER_OVERFLOW = 0x11;\\n    /// @dev division or modulo by zero\\n    uint256 internal constant DIVISION_BY_ZERO = 0x12;\\n    /// @dev enum conversion error\\n    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;\\n    /// @dev invalid encoding in storage\\n    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;\\n    /// @dev empty array pop\\n    uint256 internal constant EMPTY_ARRAY_POP = 0x31;\\n    /// @dev array out of bounds access\\n    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;\\n    /// @dev resource error (too large allocation or too large array)\\n    uint256 internal constant RESOURCE_ERROR = 0x41;\\n    /// @dev calling invalid internal function\\n    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;\\n\\n    /// @dev Reverts with a panic code. Recommended to use with\\n    /// the internal constants with predefined codes.\\n    function panic(uint256 code) internal pure {\\n        assembly (\\\"memory-safe\\\") {\\n            mstore(0x00, 0x4e487b71)\\n            mstore(0x20, code)\\n            revert(0x1c, 0x24)\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0xf7fe324703a64fc51702311dc51562d5cb1497734f074e4f483bfb6717572d7a\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/introspection/IERC165.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\\n\\npragma solidity >=0.4.16;\\n\\n/**\\n * @dev Interface of the ERC-165 standard, as defined in the\\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\\n *\\n * Implementers can declare support of contract interfaces, which can then be\\n * queried by others ({ERC165Checker}).\\n *\\n * For an implementation, see {ERC165}.\\n */\\ninterface IERC165 {\\n    /**\\n     * @dev Returns true if this contract implements the interface defined by\\n     * `interfaceId`. See the corresponding\\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\\n     * to learn more about how these ids are created.\\n     *\\n     * This function call must use less than 30 000 gas.\\n     */\\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\\n}\\n\",\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.20;\\n\\nimport {Panic} from \\\"../Panic.sol\\\";\\nimport {SafeCast} from \\\"./SafeCast.sol\\\";\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n    enum Rounding {\\n        Floor, // Toward negative infinity\\n        Ceil, // Toward positive infinity\\n        Trunc, // Toward zero\\n        Expand // Away from zero\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit addition of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that sum = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        assembly (\\\"memory-safe\\\") {\\n            low := add(a, b)\\n            high := lt(low, a)\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the 512-bit multiplication of two uint256.\\n     *\\n     * The result is stored in two 256 variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n     */\\n    function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) {\\n        // 512-bit multiply [high low] = x * y. Compute the product mod 2\\u00b2\\u2075\\u2076 and mod 2\\u00b2\\u2075\\u2076 - 1, then use\\n        // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\\n        // variables such that product = high * 2\\u00b2\\u2075\\u2076 + low.\\n        assembly (\\\"memory-safe\\\") {\\n            let mm := mulmod(a, b, not(0))\\n            low := mul(a, b)\\n            high := sub(sub(mm, low), lt(mm, low))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the addition of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a + b;\\n            success = c >= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a - b;\\n            success = c <= a;\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow).\\n     */\\n    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            uint256 c = a * b;\\n            assembly (\\\"memory-safe\\\") {\\n                // Only true when the multiplication doesn't overflow\\n                // (c / a == b) || (a == 0)\\n                success := or(eq(div(c, a), b), iszero(a))\\n            }\\n            // equivalent to: success ? c : 0\\n            result = c * SafeCast.toUint(success);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `DIV` opcode returns zero when the denominator is 0.\\n                result := div(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).\\n     */\\n    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {\\n        unchecked {\\n            success = b > 0;\\n            assembly (\\\"memory-safe\\\") {\\n                // The `MOD` opcode returns zero when the denominator is 0.\\n                result := mod(a, b)\\n            }\\n        }\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating addition, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryAdd(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing.\\n     */\\n    function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (, uint256 result) = trySub(a, b);\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Unsigned saturating multiplication, bounds to `2\\u00b2\\u2075\\u2076 - 1` instead of overflowing.\\n     */\\n    function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) {\\n        (bool success, uint256 result) = tryMul(a, b);\\n        return ternary(success, result, type(uint256).max);\\n    }\\n\\n    /**\\n     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.\\n     *\\n     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.\\n     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute\\n     * one branch when needed, making this function more expensive.\\n     */\\n    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {\\n        unchecked {\\n            // branchless ternary works because:\\n            // b ^ (a ^ b) == a\\n            // b ^ 0 == b\\n            return b ^ ((a ^ b) * SafeCast.toUint(condition));\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the largest of two numbers.\\n     */\\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a > b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the smallest of two numbers.\\n     */\\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n        return ternary(a < b, a, b);\\n    }\\n\\n    /**\\n     * @dev Returns the average of two numbers. The result is rounded towards\\n     * zero.\\n     */\\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n        // (a + b) / 2 can overflow.\\n        return (a & b) + (a ^ b) / 2;\\n    }\\n\\n    /**\\n     * @dev Returns the ceiling of the division of two numbers.\\n     *\\n     * This differs from standard division with `/` in that it rounds towards infinity instead\\n     * of rounding towards zero.\\n     */\\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n        if (b == 0) {\\n            // Guarantee the same behavior as in a regular Solidity division.\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n\\n        // The following calculation ensures accurate ceiling division without overflow.\\n        // Since a is non-zero, (a - 1) / b will not overflow.\\n        // The largest possible result occurs when (a - 1) / b is type(uint256).max,\\n        // but the largest value we can obtain is type(uint256).max - 1, which happens\\n        // when a = type(uint256).max and b = 1.\\n        unchecked {\\n            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or\\n     * denominator == 0.\\n     *\\n     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by\\n     * Uniswap Labs also under MIT license.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n\\n            // Handle non-overflow cases, 256 by 256 division.\\n            if (high == 0) {\\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\\n                // The surrounding unchecked block does not change this fact.\\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\\n                return low / denominator;\\n            }\\n\\n            // Make sure the result is less than 2\\u00b2\\u2075\\u2076. Also prevents denominator == 0.\\n            if (denominator <= high) {\\n                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));\\n            }\\n\\n            ///////////////////////////////////////////////\\n            // 512 by 256 division.\\n            ///////////////////////////////////////////////\\n\\n            // Make division exact by subtracting the remainder from [high low].\\n            uint256 remainder;\\n            assembly (\\\"memory-safe\\\") {\\n                // Compute remainder using mulmod.\\n                remainder := mulmod(x, y, denominator)\\n\\n                // Subtract 256 bit number from 512 bit number.\\n                high := sub(high, gt(remainder, low))\\n                low := sub(low, remainder)\\n            }\\n\\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.\\n            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.\\n\\n            uint256 twos = denominator & (0 - denominator);\\n            assembly (\\\"memory-safe\\\") {\\n                // Divide denominator by twos.\\n                denominator := div(denominator, twos)\\n\\n                // Divide [high low] by twos.\\n                low := div(low, twos)\\n\\n                // Flip twos such that it is 2\\u00b2\\u2075\\u2076 / twos. If twos is zero, then it becomes one.\\n                twos := add(div(sub(0, twos), twos), 1)\\n            }\\n\\n            // Shift in bits from high into low.\\n            low |= high * twos;\\n\\n            // Invert denominator mod 2\\u00b2\\u2075\\u2076. Now that denominator is an odd number, it has an inverse modulo 2\\u00b2\\u2075\\u2076 such\\n            // that denominator * inv \\u2261 1 mod 2\\u00b2\\u2075\\u2076. Compute the inverse by starting with a seed that is correct for\\n            // four bits. That is, denominator * inv \\u2261 1 mod 2\\u2074.\\n            uint256 inverse = (3 * denominator) ^ 2;\\n\\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also\\n            // works in modular arithmetic, doubling the correct bits in each step.\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u2076\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b3\\u00b2\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u2076\\u2074\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b9\\u00b2\\u2078\\n            inverse *= 2 - denominator * inverse; // inverse mod 2\\u00b2\\u2075\\u2076\\n\\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\\n            // This will give us the correct result modulo 2\\u00b2\\u2075\\u2076. Since the preconditions guarantee that the outcome is\\n            // less than 2\\u00b2\\u2075\\u2076, this is the final result. We don't need to compute the high bits of the result and high\\n            // is no longer required.\\n            result = low * inverse;\\n            return result;\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.\\n     */\\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\\n        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) {\\n        unchecked {\\n            (uint256 high, uint256 low) = mul512(x, y);\\n            if (high >= 1 << n) {\\n                Panic.panic(Panic.UNDER_OVERFLOW);\\n            }\\n            return (high << (256 - n)) | (low >> n);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates x * y >> n with full precision, following the selected rounding direction.\\n     */\\n    function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) {\\n        return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0);\\n    }\\n\\n    /**\\n     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.\\n     *\\n     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.\\n     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.\\n     *\\n     * If the input value is not inversible, 0 is returned.\\n     *\\n     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the\\n     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.\\n     */\\n    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {\\n        unchecked {\\n            if (n == 0) return 0;\\n\\n            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)\\n            // Used to compute integers x and y such that: ax + ny = gcd(a, n).\\n            // When the gcd is 1, then the inverse of a modulo n exists and it's x.\\n            // ax + ny = 1\\n            // ax = 1 + (-y)n\\n            // ax \\u2261 1 (mod n) # x is the inverse of a modulo n\\n\\n            // If the remainder is 0 the gcd is n right away.\\n            uint256 remainder = a % n;\\n            uint256 gcd = n;\\n\\n            // Therefore the initial coefficients are:\\n            // ax + ny = gcd(a, n) = n\\n            // 0a + 1n = n\\n            int256 x = 0;\\n            int256 y = 1;\\n\\n            while (remainder != 0) {\\n                uint256 quotient = gcd / remainder;\\n\\n                (gcd, remainder) = (\\n                    // The old remainder is the next gcd to try.\\n                    remainder,\\n                    // Compute the next remainder.\\n                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd\\n                    // where gcd is at most n (capped to type(uint256).max)\\n                    gcd - remainder * quotient\\n                );\\n\\n                (x, y) = (\\n                    // Increment the coefficient of a.\\n                    y,\\n                    // Decrement the coefficient of n.\\n                    // Can overflow, but the result is casted to uint256 so that the\\n                    // next value of y is \\\"wrapped around\\\" to a value between 0 and n - 1.\\n                    x - y * int256(quotient)\\n                );\\n            }\\n\\n            if (gcd != 1) return 0; // No inverse exists.\\n            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.\\n     *\\n     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is\\n     * prime, then `a**(p-1) \\u2261 1 mod p`. As a consequence, we have `a * a**(p-2) \\u2261 1 mod p`, which means that\\n     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.\\n     *\\n     * NOTE: this function does NOT check that `p` is a prime greater than `2`.\\n     */\\n    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {\\n        unchecked {\\n            return Math.modExp(a, p - 2, p);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)\\n     *\\n     * Requirements:\\n     * - modulus can't be zero\\n     * - underlying staticcall to precompile must succeed\\n     *\\n     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make\\n     * sure the chain you're using it on supports the precompiled contract for modular exponentiation\\n     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,\\n     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly\\n     * interpreted as 0.\\n     */\\n    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {\\n        (bool success, uint256 result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).\\n     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying\\n     * to operate modulo 0 or if the underlying precompile reverted.\\n     *\\n     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain\\n     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in\\n     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack\\n     * of a revert, but the result may be incorrectly interpreted as 0.\\n     */\\n    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {\\n        if (m == 0) return (false, 0);\\n        assembly (\\\"memory-safe\\\") {\\n            let ptr := mload(0x40)\\n            // | Offset    | Content    | Content (Hex)                                                      |\\n            // |-----------|------------|--------------------------------------------------------------------|\\n            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |\\n            // | 0x60:0x7f | value of b | 0x<.............................................................b> |\\n            // | 0x80:0x9f | value of e | 0x<.............................................................e> |\\n            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |\\n            mstore(ptr, 0x20)\\n            mstore(add(ptr, 0x20), 0x20)\\n            mstore(add(ptr, 0x40), 0x20)\\n            mstore(add(ptr, 0x60), b)\\n            mstore(add(ptr, 0x80), e)\\n            mstore(add(ptr, 0xa0), m)\\n\\n            // Given the result < m, it's guaranteed to fit in 32 bytes,\\n            // so we can use the memory scratch space located at offset 0.\\n            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)\\n            result := mload(0x00)\\n        }\\n    }\\n\\n    /**\\n     * @dev Variant of {modExp} that supports inputs of arbitrary length.\\n     */\\n    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {\\n        (bool success, bytes memory result) = tryModExp(b, e, m);\\n        if (!success) {\\n            Panic.panic(Panic.DIVISION_BY_ZERO);\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.\\n     */\\n    function tryModExp(\\n        bytes memory b,\\n        bytes memory e,\\n        bytes memory m\\n    ) internal view returns (bool success, bytes memory result) {\\n        if (_zeroBytes(m)) return (false, new bytes(0));\\n\\n        uint256 mLen = m.length;\\n\\n        // Encode call args in result and move the free memory pointer\\n        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);\\n\\n        assembly (\\\"memory-safe\\\") {\\n            let dataPtr := add(result, 0x20)\\n            // Write result on top of args to avoid allocating extra memory.\\n            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)\\n            // Overwrite the length.\\n            // result.length > returndatasize() is guaranteed because returndatasize() == m.length\\n            mstore(result, mLen)\\n            // Set the memory pointer after the returned data.\\n            mstore(0x40, add(dataPtr, mLen))\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether the provided byte array is zero.\\n     */\\n    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {\\n        for (uint256 i = 0; i < byteArray.length; ++i) {\\n            if (byteArray[i] != 0) {\\n                return false;\\n            }\\n        }\\n        return true;\\n    }\\n\\n    /**\\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded\\n     * towards zero.\\n     *\\n     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only\\n     * using integer operations.\\n     */\\n    function sqrt(uint256 a) internal pure returns (uint256) {\\n        unchecked {\\n            // Take care of easy edge cases when a == 0 or a == 1\\n            if (a <= 1) {\\n                return a;\\n            }\\n\\n            // In this function, we use Newton's method to get a root of `f(x) := x\\u00b2 - a`. It involves building a\\n            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between\\n            // the current value as `\\u03b5_n = | x_n - sqrt(a) |`.\\n            //\\n            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root\\n            // of the target. (i.e. `2**(e-1) \\u2264 sqrt(a) < 2**e`). We know that `e \\u2264 128` because `(2\\u00b9\\u00b2\\u2078)\\u00b2 = 2\\u00b2\\u2075\\u2076` is\\n            // bigger than any uint256.\\n            //\\n            // By noticing that\\n            // `2**(e-1) \\u2264 sqrt(a) < 2**e \\u2192 (2**(e-1))\\u00b2 \\u2264 a < (2**e)\\u00b2 \\u2192 2**(2*e-2) \\u2264 a < 2**(2*e)`\\n            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar\\n            // to the msb function.\\n            uint256 aa = a;\\n            uint256 xn = 1;\\n\\n            if (aa >= (1 << 128)) {\\n                aa >>= 128;\\n                xn <<= 64;\\n            }\\n            if (aa >= (1 << 64)) {\\n                aa >>= 64;\\n                xn <<= 32;\\n            }\\n            if (aa >= (1 << 32)) {\\n                aa >>= 32;\\n                xn <<= 16;\\n            }\\n            if (aa >= (1 << 16)) {\\n                aa >>= 16;\\n                xn <<= 8;\\n            }\\n            if (aa >= (1 << 8)) {\\n                aa >>= 8;\\n                xn <<= 4;\\n            }\\n            if (aa >= (1 << 4)) {\\n                aa >>= 4;\\n                xn <<= 2;\\n            }\\n            if (aa >= (1 << 2)) {\\n                xn <<= 1;\\n            }\\n\\n            // We now have x_n such that `x_n = 2**(e-1) \\u2264 sqrt(a) < 2**e = 2 * x_n`. This implies \\u03b5_n \\u2264 2**(e-1).\\n            //\\n            // We can refine our estimation by noticing that the middle of that interval minimizes the error.\\n            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to \\u03b5_n \\u2264 2**(e-2).\\n            // This is going to be our x_0 (and \\u03b5_0)\\n            xn = (3 * xn) >> 1; // \\u03b5_0 := | x_0 - sqrt(a) | \\u2264 2**(e-2)\\n\\n            // From here, Newton's method give us:\\n            // x_{n+1} = (x_n + a / x_n) / 2\\n            //\\n            // One should note that:\\n            // x_{n+1}\\u00b2 - a = ((x_n + a / x_n) / 2)\\u00b2 - a\\n            //              = ((x_n\\u00b2 + a) / (2 * x_n))\\u00b2 - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2) - a\\n            //              = (x_n\\u2074 + 2 * a * x_n\\u00b2 + a\\u00b2 - 4 * a * x_n\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u2074 - 2 * a * x_n\\u00b2 + a\\u00b2) / (4 * x_n\\u00b2)\\n            //              = (x_n\\u00b2 - a)\\u00b2 / (2 * x_n)\\u00b2\\n            //              = ((x_n\\u00b2 - a) / (2 * x_n))\\u00b2\\n            //              \\u2265 0\\n            // Which proves that for all n \\u2265 1, sqrt(a) \\u2264 x_n\\n            //\\n            // This gives us the proof of quadratic convergence of the sequence:\\n            // \\u03b5_{n+1} = | x_{n+1} - sqrt(a) |\\n            //         = | (x_n + a / x_n) / 2 - sqrt(a) |\\n            //         = | (x_n\\u00b2 + a - 2*x_n*sqrt(a)) / (2 * x_n) |\\n            //         = | (x_n - sqrt(a))\\u00b2 / (2 * x_n) |\\n            //         = | \\u03b5_n\\u00b2 / (2 * x_n) |\\n            //         = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //\\n            // For the first iteration, we have a special case where x_0 is known:\\n            // \\u03b5_1 = \\u03b5_0\\u00b2 / | (2 * x_0) |\\n            //     \\u2264 (2**(e-2))\\u00b2 / (2 * (2**(e-1) + 2**(e-2)))\\n            //     \\u2264 2**(2*e-4) / (3 * 2**(e-1))\\n            //     \\u2264 2**(e-3) / 3\\n            //     \\u2264 2**(e-3-log2(3))\\n            //     \\u2264 2**(e-4.5)\\n            //\\n            // For the following iterations, we use the fact that, 2**(e-1) \\u2264 sqrt(a) \\u2264 x_n:\\n            // \\u03b5_{n+1} = \\u03b5_n\\u00b2 / | (2 * x_n) |\\n            //         \\u2264 (2**(e-k))\\u00b2 / (2 * 2**(e-1))\\n            //         \\u2264 2**(2*e-2*k) / 2**e\\n            //         \\u2264 2**(e-2*k)\\n            xn = (xn + a / xn) >> 1; // \\u03b5_1 := | x_1 - sqrt(a) | \\u2264 2**(e-4.5)  -- special case, see above\\n            xn = (xn + a / xn) >> 1; // \\u03b5_2 := | x_2 - sqrt(a) | \\u2264 2**(e-9)    -- general case with k = 4.5\\n            xn = (xn + a / xn) >> 1; // \\u03b5_3 := | x_3 - sqrt(a) | \\u2264 2**(e-18)   -- general case with k = 9\\n            xn = (xn + a / xn) >> 1; // \\u03b5_4 := | x_4 - sqrt(a) | \\u2264 2**(e-36)   -- general case with k = 18\\n            xn = (xn + a / xn) >> 1; // \\u03b5_5 := | x_5 - sqrt(a) | \\u2264 2**(e-72)   -- general case with k = 36\\n            xn = (xn + a / xn) >> 1; // \\u03b5_6 := | x_6 - sqrt(a) | \\u2264 2**(e-144)  -- general case with k = 72\\n\\n            // Because e \\u2264 128 (as discussed during the first estimation phase), we know have reached a precision\\n            // \\u03b5_6 \\u2264 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either\\n            // sqrt(a) or sqrt(a) + 1.\\n            return xn - SafeCast.toUint(xn > a / xn);\\n        }\\n    }\\n\\n    /**\\n     * @dev Calculates sqrt(a), following the selected rounding direction.\\n     */\\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = sqrt(a);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // If upper 8 bits of 16-bit half set, add 8 to result\\n        r |= SafeCast.toUint((x >> r) > 0xff) << 3;\\n        // If upper 4 bits of 8-bit half set, add 4 to result\\n        r |= SafeCast.toUint((x >> r) > 0xf) << 2;\\n\\n        // Shifts value right by the current result and use it as an index into this lookup table:\\n        //\\n        // | x (4 bits) |  index  | table[index] = MSB position |\\n        // |------------|---------|-----------------------------|\\n        // |    0000    |    0    |        table[0] = 0         |\\n        // |    0001    |    1    |        table[1] = 0         |\\n        // |    0010    |    2    |        table[2] = 1         |\\n        // |    0011    |    3    |        table[3] = 1         |\\n        // |    0100    |    4    |        table[4] = 2         |\\n        // |    0101    |    5    |        table[5] = 2         |\\n        // |    0110    |    6    |        table[6] = 2         |\\n        // |    0111    |    7    |        table[7] = 2         |\\n        // |    1000    |    8    |        table[8] = 3         |\\n        // |    1001    |    9    |        table[9] = 3         |\\n        // |    1010    |   10    |        table[10] = 3        |\\n        // |    1011    |   11    |        table[11] = 3        |\\n        // |    1100    |   12    |        table[12] = 3        |\\n        // |    1101    |   13    |        table[13] = 3        |\\n        // |    1110    |   14    |        table[14] = 3        |\\n        // |    1111    |   15    |        table[15] = 3        |\\n        //\\n        // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes.\\n        assembly (\\\"memory-safe\\\") {\\n            r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000))\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log2(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value) internal pure returns (uint256) {\\n        uint256 result = 0;\\n        unchecked {\\n            if (value >= 10 ** 64) {\\n                value /= 10 ** 64;\\n                result += 64;\\n            }\\n            if (value >= 10 ** 32) {\\n                value /= 10 ** 32;\\n                result += 32;\\n            }\\n            if (value >= 10 ** 16) {\\n                value /= 10 ** 16;\\n                result += 16;\\n            }\\n            if (value >= 10 ** 8) {\\n                value /= 10 ** 8;\\n                result += 8;\\n            }\\n            if (value >= 10 ** 4) {\\n                value /= 10 ** 4;\\n                result += 4;\\n            }\\n            if (value >= 10 ** 2) {\\n                value /= 10 ** 2;\\n                result += 2;\\n            }\\n            if (value >= 10 ** 1) {\\n                result += 1;\\n            }\\n        }\\n        return result;\\n    }\\n\\n    /**\\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log10(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256 of a positive value rounded towards zero.\\n     * Returns 0 if given 0.\\n     *\\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\\n     */\\n    function log256(uint256 x) internal pure returns (uint256 r) {\\n        // If value has upper 128 bits set, log2 result is at least 128\\n        r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7;\\n        // If upper 64 bits of 128-bit half set, add 64 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6;\\n        // If upper 32 bits of 64-bit half set, add 32 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5;\\n        // If upper 16 bits of 32-bit half set, add 16 to result\\n        r |= SafeCast.toUint((x >> r) > 0xffff) << 4;\\n        // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8\\n        return (r >> 3) | SafeCast.toUint((x >> r) > 0xff);\\n    }\\n\\n    /**\\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\\n     * Returns 0 if given 0.\\n     */\\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\\n        unchecked {\\n            uint256 result = log256(value);\\n            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.\\n     */\\n    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {\\n        return uint8(rounding) % 2 == 1;\\n    }\\n}\\n\",\"keccak256\":\"0x1225214420c83ebcca88f2ae2b50f053aaa7df7bd684c3e878d334627f2edfc6\",\"license\":\"MIT\"},\"npm/@openzeppelin/contracts@5.4.0/utils/math/SafeCast.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)\\n// This file was procedurally generated from scripts/generate/templates/SafeCast.js.\\n\\npragma solidity ^0.8.20;\\n\\n/**\\n * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow\\n * checks.\\n *\\n * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can\\n * easily result in undesired exploitation or bugs, since developers usually\\n * assume that overflows raise errors. `SafeCast` restores this intuition by\\n * reverting the transaction when such an operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeCast {\\n    /**\\n     * @dev Value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);\\n\\n    /**\\n     * @dev An int value doesn't fit in an uint of `bits` size.\\n     */\\n    error SafeCastOverflowedIntToUint(int256 value);\\n\\n    /**\\n     * @dev Value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);\\n\\n    /**\\n     * @dev An uint value doesn't fit in an int of `bits` size.\\n     */\\n    error SafeCastOverflowedUintToInt(uint256 value);\\n\\n    /**\\n     * @dev Returns the downcasted uint248 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint248).\\n     *\\n     * Counterpart to Solidity's `uint248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toUint248(uint256 value) internal pure returns (uint248) {\\n        if (value > type(uint248).max) {\\n            revert SafeCastOverflowedUintDowncast(248, value);\\n        }\\n        return uint248(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint240 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint240).\\n     *\\n     * Counterpart to Solidity's `uint240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toUint240(uint256 value) internal pure returns (uint240) {\\n        if (value > type(uint240).max) {\\n            revert SafeCastOverflowedUintDowncast(240, value);\\n        }\\n        return uint240(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint232 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint232).\\n     *\\n     * Counterpart to Solidity's `uint232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toUint232(uint256 value) internal pure returns (uint232) {\\n        if (value > type(uint232).max) {\\n            revert SafeCastOverflowedUintDowncast(232, value);\\n        }\\n        return uint232(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint224 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint224).\\n     *\\n     * Counterpart to Solidity's `uint224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toUint224(uint256 value) internal pure returns (uint224) {\\n        if (value > type(uint224).max) {\\n            revert SafeCastOverflowedUintDowncast(224, value);\\n        }\\n        return uint224(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint216 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint216).\\n     *\\n     * Counterpart to Solidity's `uint216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toUint216(uint256 value) internal pure returns (uint216) {\\n        if (value > type(uint216).max) {\\n            revert SafeCastOverflowedUintDowncast(216, value);\\n        }\\n        return uint216(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint208 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint208).\\n     *\\n     * Counterpart to Solidity's `uint208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toUint208(uint256 value) internal pure returns (uint208) {\\n        if (value > type(uint208).max) {\\n            revert SafeCastOverflowedUintDowncast(208, value);\\n        }\\n        return uint208(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint200 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint200).\\n     *\\n     * Counterpart to Solidity's `uint200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toUint200(uint256 value) internal pure returns (uint200) {\\n        if (value > type(uint200).max) {\\n            revert SafeCastOverflowedUintDowncast(200, value);\\n        }\\n        return uint200(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint192 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint192).\\n     *\\n     * Counterpart to Solidity's `uint192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toUint192(uint256 value) internal pure returns (uint192) {\\n        if (value > type(uint192).max) {\\n            revert SafeCastOverflowedUintDowncast(192, value);\\n        }\\n        return uint192(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint184 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint184).\\n     *\\n     * Counterpart to Solidity's `uint184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toUint184(uint256 value) internal pure returns (uint184) {\\n        if (value > type(uint184).max) {\\n            revert SafeCastOverflowedUintDowncast(184, value);\\n        }\\n        return uint184(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint176 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint176).\\n     *\\n     * Counterpart to Solidity's `uint176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toUint176(uint256 value) internal pure returns (uint176) {\\n        if (value > type(uint176).max) {\\n            revert SafeCastOverflowedUintDowncast(176, value);\\n        }\\n        return uint176(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint168 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint168).\\n     *\\n     * Counterpart to Solidity's `uint168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toUint168(uint256 value) internal pure returns (uint168) {\\n        if (value > type(uint168).max) {\\n            revert SafeCastOverflowedUintDowncast(168, value);\\n        }\\n        return uint168(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint160 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint160).\\n     *\\n     * Counterpart to Solidity's `uint160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toUint160(uint256 value) internal pure returns (uint160) {\\n        if (value > type(uint160).max) {\\n            revert SafeCastOverflowedUintDowncast(160, value);\\n        }\\n        return uint160(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint152 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint152).\\n     *\\n     * Counterpart to Solidity's `uint152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toUint152(uint256 value) internal pure returns (uint152) {\\n        if (value > type(uint152).max) {\\n            revert SafeCastOverflowedUintDowncast(152, value);\\n        }\\n        return uint152(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint144 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint144).\\n     *\\n     * Counterpart to Solidity's `uint144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toUint144(uint256 value) internal pure returns (uint144) {\\n        if (value > type(uint144).max) {\\n            revert SafeCastOverflowedUintDowncast(144, value);\\n        }\\n        return uint144(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint136 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint136).\\n     *\\n     * Counterpart to Solidity's `uint136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toUint136(uint256 value) internal pure returns (uint136) {\\n        if (value > type(uint136).max) {\\n            revert SafeCastOverflowedUintDowncast(136, value);\\n        }\\n        return uint136(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint128 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint128).\\n     *\\n     * Counterpart to Solidity's `uint128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toUint128(uint256 value) internal pure returns (uint128) {\\n        if (value > type(uint128).max) {\\n            revert SafeCastOverflowedUintDowncast(128, value);\\n        }\\n        return uint128(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint120 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint120).\\n     *\\n     * Counterpart to Solidity's `uint120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toUint120(uint256 value) internal pure returns (uint120) {\\n        if (value > type(uint120).max) {\\n            revert SafeCastOverflowedUintDowncast(120, value);\\n        }\\n        return uint120(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint112 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint112).\\n     *\\n     * Counterpart to Solidity's `uint112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toUint112(uint256 value) internal pure returns (uint112) {\\n        if (value > type(uint112).max) {\\n            revert SafeCastOverflowedUintDowncast(112, value);\\n        }\\n        return uint112(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint104 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint104).\\n     *\\n     * Counterpart to Solidity's `uint104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toUint104(uint256 value) internal pure returns (uint104) {\\n        if (value > type(uint104).max) {\\n            revert SafeCastOverflowedUintDowncast(104, value);\\n        }\\n        return uint104(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint96 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint96).\\n     *\\n     * Counterpart to Solidity's `uint96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toUint96(uint256 value) internal pure returns (uint96) {\\n        if (value > type(uint96).max) {\\n            revert SafeCastOverflowedUintDowncast(96, value);\\n        }\\n        return uint96(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint88 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint88).\\n     *\\n     * Counterpart to Solidity's `uint88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toUint88(uint256 value) internal pure returns (uint88) {\\n        if (value > type(uint88).max) {\\n            revert SafeCastOverflowedUintDowncast(88, value);\\n        }\\n        return uint88(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint80 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint80).\\n     *\\n     * Counterpart to Solidity's `uint80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toUint80(uint256 value) internal pure returns (uint80) {\\n        if (value > type(uint80).max) {\\n            revert SafeCastOverflowedUintDowncast(80, value);\\n        }\\n        return uint80(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint72 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint72).\\n     *\\n     * Counterpart to Solidity's `uint72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toUint72(uint256 value) internal pure returns (uint72) {\\n        if (value > type(uint72).max) {\\n            revert SafeCastOverflowedUintDowncast(72, value);\\n        }\\n        return uint72(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint64 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint64).\\n     *\\n     * Counterpart to Solidity's `uint64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toUint64(uint256 value) internal pure returns (uint64) {\\n        if (value > type(uint64).max) {\\n            revert SafeCastOverflowedUintDowncast(64, value);\\n        }\\n        return uint64(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint56 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint56).\\n     *\\n     * Counterpart to Solidity's `uint56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toUint56(uint256 value) internal pure returns (uint56) {\\n        if (value > type(uint56).max) {\\n            revert SafeCastOverflowedUintDowncast(56, value);\\n        }\\n        return uint56(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint48 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint48).\\n     *\\n     * Counterpart to Solidity's `uint48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toUint48(uint256 value) internal pure returns (uint48) {\\n        if (value > type(uint48).max) {\\n            revert SafeCastOverflowedUintDowncast(48, value);\\n        }\\n        return uint48(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint40 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint40).\\n     *\\n     * Counterpart to Solidity's `uint40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toUint40(uint256 value) internal pure returns (uint40) {\\n        if (value > type(uint40).max) {\\n            revert SafeCastOverflowedUintDowncast(40, value);\\n        }\\n        return uint40(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint32 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint32).\\n     *\\n     * Counterpart to Solidity's `uint32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toUint32(uint256 value) internal pure returns (uint32) {\\n        if (value > type(uint32).max) {\\n            revert SafeCastOverflowedUintDowncast(32, value);\\n        }\\n        return uint32(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint24 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint24).\\n     *\\n     * Counterpart to Solidity's `uint24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toUint24(uint256 value) internal pure returns (uint24) {\\n        if (value > type(uint24).max) {\\n            revert SafeCastOverflowedUintDowncast(24, value);\\n        }\\n        return uint24(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint16 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint16).\\n     *\\n     * Counterpart to Solidity's `uint16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toUint16(uint256 value) internal pure returns (uint16) {\\n        if (value > type(uint16).max) {\\n            revert SafeCastOverflowedUintDowncast(16, value);\\n        }\\n        return uint16(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted uint8 from uint256, reverting on\\n     * overflow (when the input is greater than largest uint8).\\n     *\\n     * Counterpart to Solidity's `uint8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toUint8(uint256 value) internal pure returns (uint8) {\\n        if (value > type(uint8).max) {\\n            revert SafeCastOverflowedUintDowncast(8, value);\\n        }\\n        return uint8(value);\\n    }\\n\\n    /**\\n     * @dev Converts a signed int256 into an unsigned uint256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be greater than or equal to 0.\\n     */\\n    function toUint256(int256 value) internal pure returns (uint256) {\\n        if (value < 0) {\\n            revert SafeCastOverflowedIntToUint(value);\\n        }\\n        return uint256(value);\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int248 from int256, reverting on\\n     * overflow (when the input is less than smallest int248 or\\n     * greater than largest int248).\\n     *\\n     * Counterpart to Solidity's `int248` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 248 bits\\n     */\\n    function toInt248(int256 value) internal pure returns (int248 downcasted) {\\n        downcasted = int248(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(248, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int240 from int256, reverting on\\n     * overflow (when the input is less than smallest int240 or\\n     * greater than largest int240).\\n     *\\n     * Counterpart to Solidity's `int240` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 240 bits\\n     */\\n    function toInt240(int256 value) internal pure returns (int240 downcasted) {\\n        downcasted = int240(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(240, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int232 from int256, reverting on\\n     * overflow (when the input is less than smallest int232 or\\n     * greater than largest int232).\\n     *\\n     * Counterpart to Solidity's `int232` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 232 bits\\n     */\\n    function toInt232(int256 value) internal pure returns (int232 downcasted) {\\n        downcasted = int232(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(232, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int224 from int256, reverting on\\n     * overflow (when the input is less than smallest int224 or\\n     * greater than largest int224).\\n     *\\n     * Counterpart to Solidity's `int224` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 224 bits\\n     */\\n    function toInt224(int256 value) internal pure returns (int224 downcasted) {\\n        downcasted = int224(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(224, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int216 from int256, reverting on\\n     * overflow (when the input is less than smallest int216 or\\n     * greater than largest int216).\\n     *\\n     * Counterpart to Solidity's `int216` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 216 bits\\n     */\\n    function toInt216(int256 value) internal pure returns (int216 downcasted) {\\n        downcasted = int216(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(216, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int208 from int256, reverting on\\n     * overflow (when the input is less than smallest int208 or\\n     * greater than largest int208).\\n     *\\n     * Counterpart to Solidity's `int208` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 208 bits\\n     */\\n    function toInt208(int256 value) internal pure returns (int208 downcasted) {\\n        downcasted = int208(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(208, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int200 from int256, reverting on\\n     * overflow (when the input is less than smallest int200 or\\n     * greater than largest int200).\\n     *\\n     * Counterpart to Solidity's `int200` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 200 bits\\n     */\\n    function toInt200(int256 value) internal pure returns (int200 downcasted) {\\n        downcasted = int200(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(200, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int192 from int256, reverting on\\n     * overflow (when the input is less than smallest int192 or\\n     * greater than largest int192).\\n     *\\n     * Counterpart to Solidity's `int192` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 192 bits\\n     */\\n    function toInt192(int256 value) internal pure returns (int192 downcasted) {\\n        downcasted = int192(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(192, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int184 from int256, reverting on\\n     * overflow (when the input is less than smallest int184 or\\n     * greater than largest int184).\\n     *\\n     * Counterpart to Solidity's `int184` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 184 bits\\n     */\\n    function toInt184(int256 value) internal pure returns (int184 downcasted) {\\n        downcasted = int184(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(184, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int176 from int256, reverting on\\n     * overflow (when the input is less than smallest int176 or\\n     * greater than largest int176).\\n     *\\n     * Counterpart to Solidity's `int176` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 176 bits\\n     */\\n    function toInt176(int256 value) internal pure returns (int176 downcasted) {\\n        downcasted = int176(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(176, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int168 from int256, reverting on\\n     * overflow (when the input is less than smallest int168 or\\n     * greater than largest int168).\\n     *\\n     * Counterpart to Solidity's `int168` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 168 bits\\n     */\\n    function toInt168(int256 value) internal pure returns (int168 downcasted) {\\n        downcasted = int168(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(168, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int160 from int256, reverting on\\n     * overflow (when the input is less than smallest int160 or\\n     * greater than largest int160).\\n     *\\n     * Counterpart to Solidity's `int160` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 160 bits\\n     */\\n    function toInt160(int256 value) internal pure returns (int160 downcasted) {\\n        downcasted = int160(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(160, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int152 from int256, reverting on\\n     * overflow (when the input is less than smallest int152 or\\n     * greater than largest int152).\\n     *\\n     * Counterpart to Solidity's `int152` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 152 bits\\n     */\\n    function toInt152(int256 value) internal pure returns (int152 downcasted) {\\n        downcasted = int152(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(152, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int144 from int256, reverting on\\n     * overflow (when the input is less than smallest int144 or\\n     * greater than largest int144).\\n     *\\n     * Counterpart to Solidity's `int144` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 144 bits\\n     */\\n    function toInt144(int256 value) internal pure returns (int144 downcasted) {\\n        downcasted = int144(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(144, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int136 from int256, reverting on\\n     * overflow (when the input is less than smallest int136 or\\n     * greater than largest int136).\\n     *\\n     * Counterpart to Solidity's `int136` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 136 bits\\n     */\\n    function toInt136(int256 value) internal pure returns (int136 downcasted) {\\n        downcasted = int136(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(136, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int128 from int256, reverting on\\n     * overflow (when the input is less than smallest int128 or\\n     * greater than largest int128).\\n     *\\n     * Counterpart to Solidity's `int128` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 128 bits\\n     */\\n    function toInt128(int256 value) internal pure returns (int128 downcasted) {\\n        downcasted = int128(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(128, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int120 from int256, reverting on\\n     * overflow (when the input is less than smallest int120 or\\n     * greater than largest int120).\\n     *\\n     * Counterpart to Solidity's `int120` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 120 bits\\n     */\\n    function toInt120(int256 value) internal pure returns (int120 downcasted) {\\n        downcasted = int120(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(120, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int112 from int256, reverting on\\n     * overflow (when the input is less than smallest int112 or\\n     * greater than largest int112).\\n     *\\n     * Counterpart to Solidity's `int112` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 112 bits\\n     */\\n    function toInt112(int256 value) internal pure returns (int112 downcasted) {\\n        downcasted = int112(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(112, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int104 from int256, reverting on\\n     * overflow (when the input is less than smallest int104 or\\n     * greater than largest int104).\\n     *\\n     * Counterpart to Solidity's `int104` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 104 bits\\n     */\\n    function toInt104(int256 value) internal pure returns (int104 downcasted) {\\n        downcasted = int104(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(104, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int96 from int256, reverting on\\n     * overflow (when the input is less than smallest int96 or\\n     * greater than largest int96).\\n     *\\n     * Counterpart to Solidity's `int96` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 96 bits\\n     */\\n    function toInt96(int256 value) internal pure returns (int96 downcasted) {\\n        downcasted = int96(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(96, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int88 from int256, reverting on\\n     * overflow (when the input is less than smallest int88 or\\n     * greater than largest int88).\\n     *\\n     * Counterpart to Solidity's `int88` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 88 bits\\n     */\\n    function toInt88(int256 value) internal pure returns (int88 downcasted) {\\n        downcasted = int88(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(88, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int80 from int256, reverting on\\n     * overflow (when the input is less than smallest int80 or\\n     * greater than largest int80).\\n     *\\n     * Counterpart to Solidity's `int80` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 80 bits\\n     */\\n    function toInt80(int256 value) internal pure returns (int80 downcasted) {\\n        downcasted = int80(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(80, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int72 from int256, reverting on\\n     * overflow (when the input is less than smallest int72 or\\n     * greater than largest int72).\\n     *\\n     * Counterpart to Solidity's `int72` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 72 bits\\n     */\\n    function toInt72(int256 value) internal pure returns (int72 downcasted) {\\n        downcasted = int72(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(72, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int64 from int256, reverting on\\n     * overflow (when the input is less than smallest int64 or\\n     * greater than largest int64).\\n     *\\n     * Counterpart to Solidity's `int64` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 64 bits\\n     */\\n    function toInt64(int256 value) internal pure returns (int64 downcasted) {\\n        downcasted = int64(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(64, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int56 from int256, reverting on\\n     * overflow (when the input is less than smallest int56 or\\n     * greater than largest int56).\\n     *\\n     * Counterpart to Solidity's `int56` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 56 bits\\n     */\\n    function toInt56(int256 value) internal pure returns (int56 downcasted) {\\n        downcasted = int56(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(56, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int48 from int256, reverting on\\n     * overflow (when the input is less than smallest int48 or\\n     * greater than largest int48).\\n     *\\n     * Counterpart to Solidity's `int48` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 48 bits\\n     */\\n    function toInt48(int256 value) internal pure returns (int48 downcasted) {\\n        downcasted = int48(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(48, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int40 from int256, reverting on\\n     * overflow (when the input is less than smallest int40 or\\n     * greater than largest int40).\\n     *\\n     * Counterpart to Solidity's `int40` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 40 bits\\n     */\\n    function toInt40(int256 value) internal pure returns (int40 downcasted) {\\n        downcasted = int40(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(40, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int32 from int256, reverting on\\n     * overflow (when the input is less than smallest int32 or\\n     * greater than largest int32).\\n     *\\n     * Counterpart to Solidity's `int32` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 32 bits\\n     */\\n    function toInt32(int256 value) internal pure returns (int32 downcasted) {\\n        downcasted = int32(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(32, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int24 from int256, reverting on\\n     * overflow (when the input is less than smallest int24 or\\n     * greater than largest int24).\\n     *\\n     * Counterpart to Solidity's `int24` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 24 bits\\n     */\\n    function toInt24(int256 value) internal pure returns (int24 downcasted) {\\n        downcasted = int24(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(24, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int16 from int256, reverting on\\n     * overflow (when the input is less than smallest int16 or\\n     * greater than largest int16).\\n     *\\n     * Counterpart to Solidity's `int16` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 16 bits\\n     */\\n    function toInt16(int256 value) internal pure returns (int16 downcasted) {\\n        downcasted = int16(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(16, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Returns the downcasted int8 from int256, reverting on\\n     * overflow (when the input is less than smallest int8 or\\n     * greater than largest int8).\\n     *\\n     * Counterpart to Solidity's `int8` operator.\\n     *\\n     * Requirements:\\n     *\\n     * - input must fit into 8 bits\\n     */\\n    function toInt8(int256 value) internal pure returns (int8 downcasted) {\\n        downcasted = int8(value);\\n        if (downcasted != value) {\\n            revert SafeCastOverflowedIntDowncast(8, value);\\n        }\\n    }\\n\\n    /**\\n     * @dev Converts an unsigned uint256 into a signed int256.\\n     *\\n     * Requirements:\\n     *\\n     * - input must be less than or equal to maxInt256.\\n     */\\n    function toInt256(uint256 value) internal pure returns (int256) {\\n        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive\\n        if (value > uint256(type(int256).max)) {\\n            revert SafeCastOverflowedUintToInt(value);\\n        }\\n        return int256(value);\\n    }\\n\\n    /**\\n     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.\\n     */\\n    function toUint(bool b) internal pure returns (uint256 u) {\\n        assembly (\\\"memory-safe\\\") {\\n            u := iszero(iszero(b))\\n        }\\n    }\\n}\\n\",\"keccak256\":\"0x195533c86d0ef72bcc06456a4f66a9b941f38eb403739b00f21fd7c1abd1ae54\",\"license\":\"MIT\"},\"project/contracts/interfaces/IManager.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `IManager` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IManager.sol\\ninterface IManager {\\n  /// @notice Returns the amount of collateral managed by the Manager\\n  /// @return balances Balances of all the subCollaterals handled by the manager\\n  /// @dev MUST NOT revert\\n  function totalAssets() external view returns (uint256[] memory balances, uint256 totalValue);\\n\\n  /// @notice Hook to invest `amount` of `collateral`\\n  /// @dev MUST revert if the manager cannot accept these funds\\n  /// @dev MUST have received the funds beforehand\\n  function invest(uint256 amount) external;\\n\\n  /// @notice Sends `amount` of `collateral` to the `to` address\\n  /// @dev Called when `tokenP` are burnt and during redemptions\\n  //  @dev MUST revert if there are not funds enough available\\n  /// @dev MUST be callable only by the parallelizer\\n  function release(address asset, address to, uint256 amount) external;\\n\\n  /// @notice Gives the maximum amount of collateral immediately available for a transfer\\n  /// @dev Useful for integrators using `quoteIn` and `quoteOut`\\n  function maxAvailable() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x8507172834f0243643fcf366bff6bae8f20523d102f5896f2140946975458e2c\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/IParallelizerOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\n/// @title IParallelizerOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ITransmuterOracle` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ITransmuterOracle.sol\\ninterface IParallelizerOracle {\\n  /// @notice Reads the oracle value for asset to use in a redemption to compute the collateral ratio\\n  function readRedemption() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a mint. It should be comprehensive of the\\n  /// deviation from the target price\\n  function readMint() external view returns (uint256);\\n\\n  /// @notice Reads the oracle value for asset to use in a burn transaction as well as the ratio\\n  /// between the current price and the target price for the asset\\n  function readBurn() external view returns (uint256 oracleValue, uint256 ratio);\\n\\n  /// @notice Reads the oracle value for asset\\n  function read() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x1efe82def8da7cdbf7378004558354bfc63610f40760e56340f6b4c5bb1273e6\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ISetters.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\n\\nimport \\\"../parallelizer/Storage.sol\\\";\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This interface is an authorized fork of Angle's `ISettersGovernor` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/ISetters.sol\\ninterface ISettersGovernor {\\n  /// @notice Recovers `amount` of `token` from the Parallelizer contract\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external;\\n\\n  /// @notice Sets a new access manager address\\n  function setAccessManager(address _newAccessManager) external;\\n\\n  /// @notice Sets (or unsets) a collateral manager  `collateral`\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before setting the new manager\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external;\\n\\n  /// @notice Sets the allowance of the contract on `token` for `spender` to `amount`\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external;\\n\\n  /// @notice Changes the trusted status for `sender` when for selling rewards or updating the normalizer\\n  function toggleTrusted(address sender, TrustedType t) external;\\n\\n  /// @notice Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted\\n  /// addresses\\n  /// and sets the data used to read into the whitelist\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) external;\\n\\n  /// @notice Add `collateral` as a supported collateral in the system\\n  function addCollateral(address collateral) external;\\n\\n  /// @notice Adjusts the amount of stablecoins issued from `collateral` by `amount`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external;\\n\\n  /// @notice Revokes `collateral` from the system\\n  /// @dev If `checkExternalManagerBalance` is true, the function will check that the current manager no longer has\\n  /// assets before revoking the collateral\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external;\\n\\n  /// @notice Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption\\n  /// operations\\n  function setOracle(address collateral, bytes memory oracleConfig) external;\\n\\n  /// @notice Update oracle data for a given `collateral`\\n  function updateOracle(address collateral) external;\\n\\n  /// @notice Updates the payees and their shares\\n  /// @param _payees The new payee addresses\\n  /// @param _shares The new shares for each payee\\n  /// @param _skipRelease If true, skips the automatic income release before updating\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external;\\n\\n  /// @notice Updates the slippage tolerance for a `collateral`\\n  /// @dev Maximum slippage tolerance is 1e9 (100%)\\n  /// @dev The slippage tolerance is used to compute the minimum expected amount of stablecoins to be received when\\n  /// calling the `processSurplus` function\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external;\\n\\n  /// @notice Updates the surplus buffer ratio\\n  /// @dev The surplus buffer ratio is the minimum collateral ratio required after surplus processing\\n  /// @param _surplusBufferRatio The new surplus buffer ratio in BASE_9\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external;\\n\\n  /// @notice Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  /// @dev The payload is executed with a raw call, so any router can be configured. It is chain\\n  /// specific and must be set on every deployment before rewards can be sold\\n  function setSwapRouter(address swapRouter) external;\\n}\\n\\n/// @title ISettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\ninterface ISettersGuardian {\\n  /// @notice Pauses `action` for `collateral` (or pauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is already paused.\\n  function pause(address collateral, ActionType action) external;\\n\\n  /// @notice Unpauses `action` for `collateral` (or unpauses redemption protocol-wide when\\n  /// `action == Redeem`). Reverts if the action is not paused.\\n  function unpause(address collateral, ActionType action) external;\\n\\n  /// @notice Sets the mint or burn fees for `collateral`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) external;\\n\\n  /// @notice Sets the parameters for the redemption curve\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) external;\\n\\n  /// @notice Changes the whitelist status for a collateral with `whitelistType` for an address `who`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) external;\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a `collateral`\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) external;\\n}\\n\",\"keccak256\":\"0xe62d2880420afb053498b01f1def17d4c8e2c6c9b48cc5a71d013150a5ca8db4\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/ITokenP.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/// @title ITokenP\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Interface for the stablecoins `tokenP` contracts\\n/// @dev This interface is an authorized fork of Angle's `IAgToken` interface\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/interfaces/IAgToken.sol\\ninterface ITokenP is IERC20 {\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    MINTER ROLE ONLY FUNCTIONS                                            \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Lets a whitelisted contract mint tokenPs\\n  /// @param account Address to mint to\\n  /// @param amount Amount to mint\\n  function mint(address account, uint256 amount) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address after being asked to by `sender`\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @param sender Address which requested the burn from `burner`\\n  /// @dev This method is to be called by a contract with the minter right after being requested\\n  /// to do so by a `sender` address willing to burn tokens from another `burner` address\\n  /// @dev The method checks the allowance between the `sender` and the `burner`\\n  function burnFrom(uint256 amount, address burner, address sender) external;\\n\\n  /// @notice Burns `amount` tokens from a `burner` address\\n  /// @param amount Amount of tokens to burn\\n  /// @param burner Address to burn from\\n  /// @dev This method is to be called by a contract with a minter right on the tokenP after being\\n  /// requested to do so by an address willing to burn tokens from its address\\n  function burnSelf(uint256 amount, address burner) external;\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    EXTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Amount of decimals of the stablecoin\\n  function decimals() external view returns (uint8);\\n}\\n\",\"keccak256\":\"0x64a1305faa8c5c91767a11af0eae16e4b463aa0bfe10f11b74aae9d96681a5eb\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\ninterface AggregatorV3Interface {\\n  function decimals() external view returns (uint8);\\n\\n  function description() external view returns (string memory);\\n\\n  function version() external view returns (uint256);\\n\\n  // getRoundData and latestRoundData should both raise \\\"No data present\\\"\\n  // if they do not have data to report, instead of returning unset values\\n  // which could be misinterpreted as actual reported values.\\n  function getRoundData(uint80 _roundId)\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n\\n  function latestRoundData()\\n    external\\n    view\\n    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);\\n}\\n\",\"keccak256\":\"0x94da577160ebb1bfeb7008676c8e7d43dda926d9c0beee29077e9ed774707373\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/coinbase/ICbETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ICbETH\\n/// @notice Interface for the `cbETH` contract\\ninterface ICbETH {\\n  function exchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xb159341cb0e25c478912b274cdda2d50fa84692aeac87b6823d281aaea2aed04\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/frax/ISfrxETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title ISfrxETH\\n/// @notice Interface for the `sfrxETH` contract\\ninterface ISfrxETH {\\n  function pricePerShare() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x914cbea276f817c7db62bfca21e15bd8f7892faa9f39d86baaef574cf12b859f\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/keyring/IKeyringGuard.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IKeyringGuard\\n/// @notice Interface for the `KeyringGuard` contract\\ninterface IKeyringGuard {\\n  function isAuthorized(address from, address to) external returns (bool passed);\\n}\\n\",\"keccak256\":\"0x30bdab602ba0a6e2571372803ae35f7bebcc354d69408be627c04c57f7071f90\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/lido/IStETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IStETH\\n/// @notice Interface for the `StETH` contract\\ninterface IStETH {\\n  function getPooledEthByShares(uint256 _sharesAmount) external view returns (uint256);\\n\\n  function submit(address) external payable returns (uint256);\\n\\n  function getSharesByPooledEth(uint256 _ethAmount) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xf21e3d8bdadc236b34bf2122b0e0b939d2d6bb6e2889b508636cbb7b84f59680\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/morpho/IMorphoOracle.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IMorphoOracle\\n/// @notice Interface for the oracle contracts used within Morpho\\ninterface IMorphoOracle {\\n  function price() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x0d1849803b554763f1dce55eba5a6e8d7c5b12d4cc8dfe23637e827d2ee91d17\",\"license\":\"GPL-3.0\"},\"project/contracts/interfaces/external/rocketPool/IRETH.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity >=0.5.0;\\n\\n/// @title IRETH\\n/// @notice Interface for the `rETH` contract\\ninterface IRETH {\\n  function getExchangeRate() external view returns (uint256);\\n}\\n\",\"keccak256\":\"0x567a378e95d40160e297c1adb617ccaa69c03e49c4ad72a6ce651dd43cdbd5cd\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/Storage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { ITokenP } from \\\"contracts/interfaces/ITokenP.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                        ENUMS                                                      \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nenum FacetCutAction {\\n  Add,\\n  Replace,\\n  Remove\\n}\\n\\nenum ManagerType {\\n  EXTERNAL\\n}\\n\\nenum ActionType {\\n  Mint,\\n  Burn,\\n  Redeem\\n}\\n\\nenum TrustedType {\\n  Updater,\\n  Seller\\n}\\n\\nenum QuoteType {\\n  MintExactInput,\\n  MintExactOutput,\\n  BurnExactInput,\\n  BurnExactOutput\\n}\\n\\nenum OracleReadType {\\n  CHAINLINK_FEEDS,\\n  EXTERNAL,\\n  NO_ORACLE,\\n  STABLE,\\n  WSTETH,\\n  CBETH,\\n  RETH,\\n  SFRXETH,\\n  MAX,\\n  MORPHO_ORACLE\\n}\\n\\nenum OracleQuoteType {\\n  UNIT,\\n  TARGET\\n}\\n\\nenum WhitelistType {\\n  BACKED\\n}\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                    STRUCTS                                                     \\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nstruct Permit2Details {\\n  address to; // Address that will receive the funds\\n  uint256 nonce; // Nonce of the transaction\\n  bytes signature; // Permit signature of the user\\n}\\n\\nstruct AuthorizationParams {\\n  address from; // Payer's address (Authorizer)\\n  uint256 value; // Amount authorized to be transferred\\n  uint256 validAfter; // The time after which this is valid (unix time)\\n  uint256 validBefore; // The time before which this is valid (unix time)\\n  bytes32 nonce; // Unique nonce\\n  bytes signature; // EOA (r,s,v packed) or arbitrary-length EIP-1271 contract signature\\n}\\n\\nstruct FacetCut {\\n  address facetAddress; // Facet contract address\\n  FacetCutAction action; // Can be add, remove or replace\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct Facet {\\n  address facetAddress; // Facet contract address\\n  bytes4[] functionSelectors; // Ex. bytes4(keccak256(\\\"transfer(address,uint256)\\\"))\\n}\\n\\nstruct FacetInfo {\\n  address facetAddress; // Facet contract address\\n  uint16 selectorPosition; // Position in the list of all selectors\\n}\\n\\nstruct DiamondStorage {\\n  bytes4[] selectors; // List of all available selectors\\n  mapping(bytes4 => FacetInfo) selectorInfo; // Selector to (address, position in list)\\n  IAccessManager accessManager; // Contract handling access management\\n}\\n\\nstruct ImplementationStorage {\\n  address implementation; // Dummy implementation address for Etherscan usability\\n}\\n\\nstruct ManagerStorage {\\n  IERC20[] subCollaterals; // Subtokens handled by the manager or strategies\\n  bytes config; // Additional configuration data\\n}\\n\\nstruct Collateral {\\n  uint8 isManaged; // If the collateral is managed through external strategies\\n  uint8 isMintLive; // If minting from this asset is unpaused\\n  uint8 isBurnLive; // If burning to this asset is unpaused\\n  uint8 decimals; // IERC20Metadata(collateral).decimals()\\n  uint8 onlyWhitelisted; // If only whitelisted addresses can burn or redeem for this token\\n  uint216 normalizedStables; // Normalized amount of stablecoins issued from this collateral\\n  uint64[] xFeeMint; // Increasing exposures in [0,BASE_9[\\n  int64[] yFeeMint; // Mint fees at the exposures specified in `xFeeMint`\\n  uint64[] xFeeBurn; // Decreasing exposures in ]0,BASE_9]\\n  int64[] yFeeBurn; // Burn fees at the exposures specified in `xFeeBurn`\\n  bytes oracleConfig; // Data about the oracle used for the collateral\\n  bytes whitelistData; // For whitelisted collateral, data used to verify whitelists\\n  ManagerStorage managerData; // For managed collateral, data used to handle the strategies\\n  uint256 stablecoinCap; // Cap on the amount of stablecoins that can be issued from this collateral\\n}\\n\\nstruct ParallelizerStorage {\\n  ITokenP tokenP; // tokenP handled by the system\\n  uint8 isRedemptionLive; // If redemption is unpaused\\n  uint8 statusReentrant; // If call is reentrant or not\\n  bool consumingSchedule; // If the contract is consuming a scheduled operation\\n  uint128 normalizedStables; // Normalized amount of stablecoins issued by the system\\n  uint128 normalizer; // To reconcile `normalizedStables` values with the actual amount\\n  address[] collateralList; // List of collateral assets supported by the system\\n  uint64[] xRedemptionCurve; // Increasing collateral ratios > 0\\n  int64[] yRedemptionCurve; // Value of the redemption fees at `xRedemptionCurve`\\n  mapping(address => Collateral) collaterals; // Maps a collateral asset to its parameters\\n  mapping(address => uint256) isTrusted; // If an address is trusted to update the normalizer value\\n  mapping(address => uint256) isSellerTrusted; // If an address is trusted to sell accruing reward tokens or to run\\n    // keeper jobs on oracles\\n  mapping(WhitelistType => mapping(address => uint256)) isWhitelistedForType; // Whether an address is whitelisted for\\n    // a specific whitelist type\\n  // Used for the surplus distribution\\n  mapping(address => uint256) slippageTolerance;\\n  uint64 surplusBufferRatio; // Minimum collateral ratio required after surplus processing\\n  uint256 lastReleasedAt;\\n  uint256 totalShares; // The total shares of the totalShares for all payees\\n  address[] payees; // The addresses of the payees\\n  mapping(address => uint256) shares; // The shares of the totalShares for each payee\\n  // Aggregator or DEX the `RewardHandler` forwards its swap payload to\\n  address swapRouter;\\n}\\n\",\"keccak256\":\"0x310e015008150bcaf10246fa5b1ec4ce4c5e2ba2ec9ef30dcbbfb4eb407d70c3\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/AccessManagedModifiers.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { LibDiamond } from \\\"../libraries/LibDiamond.sol\\\";\\nimport { LibStorage as s, ParallelizerStorage } from \\\"../libraries/LibStorage.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\n\\n/// @title AccessManagedModifiers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `AccessControlModifiers` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/AccessControlModifiers.sol\\n/// update access logic to use OpenZeppelin's `AccessManaged` logic\\ncontract AccessManagedModifiers {\\n  /// @notice Checks whether the `msg.sender` can call a function with a given selector\\n  modifier restricted() {\\n    if (!LibDiamond.checkCanCall(msg.sender, msg.data)) revert AccessManagedUnauthorized(msg.sender);\\n    _;\\n  }\\n\\n  /// @notice Prevents a contract from calling itself, directly or indirectly\\n  /// @dev This implementation is an adaptation of the OpenZepellin `ReentrancyGuard` for the purpose of this\\n  /// Diamond Proxy system. The base implementation can be found here\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol\\n  modifier nonReentrant() {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    // Reentrant protection\\n    // On the first call, `ts.statusReentrant` will be `NOT_ENTERED`\\n    if (ts.statusReentrant == ENTERED) revert ReentrantCall();\\n    // Any calls to the `nonReentrant` modifier after this point will fail\\n    ts.statusReentrant = ENTERED;\\n\\n    _;\\n\\n    // By storing the original value once again, a refund is triggered (see\\n    // https://eips.ethereum.org/EIPS/eip-2200)\\n    ts.statusReentrant = NOT_ENTERED;\\n  }\\n}\\n\",\"keccak256\":\"0xa44d232cccfb0c1752bc298d6f6743fff60b4a9e947725f1ec476f04f11003e1\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/facets/SettersGovernor.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\n\\nimport { ISettersGovernor } from \\\"contracts/interfaces/ISetters.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibSetters } from \\\"../libraries/LibSetters.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\nimport { AccessManagedModifiers } from \\\"./AccessManagedModifiers.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title SettersGovernor\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This contract is an authorized fork of Angle's `SettersGovernor` contract\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/facets/SettersGovernor.sol\\ncontract SettersGovernor is AccessManagedModifiers, ISettersGovernor {\\n  using SafeERC20 for IERC20;\\n\\n  event Recovered(address indexed token, address indexed to, uint256 amount);\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev No check is made on the collateral that is redeemed: this function could typically be used by a\\n  /// governance during a manual rebalance of the reserves of the system\\n  /// @dev `collateral` is different from `token` only in the case of a managed collateral\\n  function recoverERC20(address collateral, IERC20 token, address to, uint256 amount) external restricted {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) LibManager.release(address(token), to, amount, collatInfo.managerData.config);\\n    else token.safeTransfer(to, amount);\\n    emit Recovered(address(token), to, amount);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setAccessManager(address _newAccessManager) external restricted {\\n    LibSetters.setAccessManager(IAccessManager(_newAccessManager));\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Funds need to have been withdrawn from the eventual previous manager prior to this call\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setCollateralManager(collateral, checkExternalManagerBalance, managerData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev This function can typically be used to grant allowance to a newly added manager for it to pull the\\n  /// funds associated to the collateral it corresponds to\\n  function changeAllowance(IERC20 token, address spender, uint256 amount) external restricted {\\n    uint256 currentAllowance = token.allowance(address(this), spender);\\n    if (currentAllowance < amount) {\\n      token.safeIncreaseAllowance(spender, amount - currentAllowance);\\n    } else if (currentAllowance > amount) {\\n      token.safeDecreaseAllowance(spender, currentAllowance - amount);\\n    }\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function toggleTrusted(address sender, TrustedType t) external restricted {\\n    LibSetters.toggleTrusted(sender, t);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Collateral assets with a fee on transfer are not supported by the system\\n  function addCollateral(address collateral) external restricted {\\n    LibSetters.addCollateral(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev The amount passed here must be an absolute amount\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) external restricted {\\n    LibSetters.adjustStablecoins(collateral, amount, increase);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  /// @dev Require `collatInfo.normalizedStables == 0`, that is to say that the collateral\\n  /// is not used to back stables\\n  /// @dev The system may still have a non null balance of the collateral that is revoked: this should later\\n  /// be handled through a recoverERC20 call\\n  /// @dev Funds needs to have been withdrew from the manager prior to this call if `checkExternalManagerBalance` is\\n  /// true\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) external restricted {\\n    LibSetters.revokeCollateral(collateral, checkExternalManagerBalance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setOracle(address collateral, bytes memory oracleConfig) external restricted {\\n    LibSetters.setOracle(collateral, oracleConfig);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateOracle(address collateral) external {\\n    if (s.transmuterStorage().isSellerTrusted[msg.sender] == 0) revert NotTrusted();\\n    LibOracle.updateOracle(collateral);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setWhitelistStatus(\\n    address collateral,\\n    uint8 whitelistStatus,\\n    bytes memory whitelistData\\n  )\\n    external\\n    restricted\\n  {\\n    LibSetters.setWhitelistStatus(collateral, whitelistStatus, whitelistData);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) external restricted {\\n    LibSetters.updatePayees(_payees, _shares, _skipRelease);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) external restricted {\\n    LibSetters.updateSlippageTolerance(collateral, slippageTolerance);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) external restricted {\\n    LibSetters.updateSurplusBufferRatio(_surplusBufferRatio);\\n  }\\n\\n  /// @inheritdoc ISettersGovernor\\n  function setSwapRouter(address swapRouter) external restricted {\\n    LibSetters.setSwapRouter(swapRouter);\\n  }\\n}\\n\",\"keccak256\":\"0x7c64a27bfb326989b6fdc21b3982ef5ce95aa2a576a4edc6d8334a8820f3b8fb\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibDiamond.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity 0.8.28;\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { IAccessManager } from \\\"@openzeppelin/contracts/access/manager/IAccessManager.sol\\\";\\nimport { AuthorityUtils } from \\\"@openzeppelin/contracts/access/manager/AuthorityUtils.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibDiamond\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @notice Helper library to deal with diamond proxies.\\n/// @dev Reference: EIP-2535 Diamonds\\n/// @dev Forked from https://github.com/mudgen/diamond-3/blob/master/contracts/libraries/LibDiamond.sol by mudgen\\nlibrary LibDiamond {\\n  event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    INTERNAL FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  function isGovernor(address caller) internal view returns (bool) {\\n    (bool isMember,) = s.diamondStorage().accessManager.hasRole(GOVERNOR_ROLE, caller);\\n    return isMember;\\n  }\\n\\n  /// @notice Checks whether `caller` can call `data` on `this`\\n  function checkCanCall(address caller, bytes calldata data) internal returns (bool) {\\n    IAccessManager accessManager = s.diamondStorage().accessManager;\\n    (bool immediate, uint32 delay) =\\n      AuthorityUtils.canCallWithDelay(address(accessManager), caller, address(this), bytes4(data[0:4]));\\n    if (!immediate) {\\n      if (delay > 0) {\\n        ParallelizerStorage storage ts = s.transmuterStorage();\\n        ts.consumingSchedule = true;\\n        accessManager.consumeScheduledOp(caller, data);\\n        ts.consumingSchedule = false;\\n      } else {\\n        return false;\\n      }\\n    }\\n    return true;\\n  }\\n\\n  /// @notice Internal function version of `diamondCut`\\n  function diamondCut(FacetCut[] memory _diamondCut, address _init, bytes memory _calldata) internal {\\n    uint256 diamondCutLength = _diamondCut.length;\\n    for (uint256 facetIndex; facetIndex < diamondCutLength; facetIndex++) {\\n      bytes4[] memory functionSelectors = _diamondCut[facetIndex].functionSelectors;\\n      address facetAddress = _diamondCut[facetIndex].facetAddress;\\n\\n      if (functionSelectors.length == 0) {\\n        revert NoSelectorsProvidedForFacetForCut(facetAddress);\\n      }\\n\\n      FacetCutAction action = _diamondCut[facetIndex].action;\\n      if (action == FacetCutAction.Add) {\\n        _addFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Replace) {\\n        _replaceFunctions(facetAddress, functionSelectors);\\n      } else if (action == FacetCutAction.Remove) {\\n        _removeFunctions(facetAddress, functionSelectors);\\n      }\\n    }\\n\\n    emit DiamondCut(_diamondCut, _init, _calldata);\\n    _initializeDiamondCut(_init, _calldata);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    PRIVATE FUNCTIONS                                                \\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Does a delegate call on `_init` with `_calldata`\\n  function _initializeDiamondCut(address _init, bytes memory _calldata) private {\\n    if (_init == address(0)) {\\n      return;\\n    }\\n    _enforceHasContractCode(_init);\\n    (bool success, bytes memory error) = _init.delegatecall(_calldata);\\n    if (!success) {\\n      if (error.length > 0) {\\n        assembly (\\\"memory-safe\\\") {\\n          let returndata_size := mload(error)\\n          revert(add(32, error), returndata_size)\\n        }\\n      } else {\\n        revert InitializationFunctionReverted(_init, _calldata);\\n      }\\n    }\\n  }\\n\\n  /// @notice Adds a new function to the diamond proxy\\n  /// @dev Reverts if selectors are already existing\\n  function _addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    if (_facetAddress == address(0)) {\\n      revert CannotAddSelectorsToZeroAddress(_functionSelectors);\\n    }\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint16 selectorCount = uint16(ds.selectors.length);\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      if (oldFacetAddress != address(0)) {\\n        revert CannotAddFunctionToDiamondThatAlreadyExists(selector);\\n      }\\n      ds.selectorInfo[selector] = FacetInfo(_facetAddress, selectorCount);\\n      ds.selectors.push(selector);\\n      selectorCount++;\\n    }\\n  }\\n\\n  /// @notice Upgrades a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    if (_facetAddress == address(0)) {\\n      revert CannotReplaceFunctionsFromFacetWithZeroAddress(_functionSelectors);\\n    }\\n    _enforceHasContractCode(_facetAddress);\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      address oldFacetAddress = ds.selectorInfo[selector].facetAddress;\\n      // Can't replace immutable functions -- functions defined directly in the diamond in this case\\n      if (oldFacetAddress == address(this)) {\\n        revert CannotReplaceImmutableFunction(selector);\\n      }\\n      if (oldFacetAddress == _facetAddress) {\\n        revert CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(selector);\\n      }\\n      if (oldFacetAddress == address(0)) {\\n        revert CannotReplaceFunctionThatDoesNotExists(selector);\\n      }\\n      // Replace old facet address\\n      ds.selectorInfo[selector].facetAddress = _facetAddress;\\n    }\\n  }\\n\\n  /// @notice Removes a function in the diamond proxy\\n  /// @dev Reverts if selectors do not already exist\\n  function _removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) private {\\n    DiamondStorage storage ds = s.diamondStorage();\\n    uint256 selectorCount = ds.selectors.length;\\n    if (_facetAddress != address(0)) {\\n      revert RemoveFacetAddressMustBeZeroAddress(_facetAddress);\\n    }\\n    uint256 functionSelectorsLength = _functionSelectors.length;\\n    for (uint256 selectorIndex; selectorIndex < functionSelectorsLength; selectorIndex++) {\\n      bytes4 selector = _functionSelectors[selectorIndex];\\n      FacetInfo memory oldFacetAddressAndSelectorPosition = ds.selectorInfo[selector];\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(0)) {\\n        revert CannotRemoveFunctionThatDoesNotExist(selector);\\n      }\\n\\n      // Can't remove immutable functions -- functions defined directly in the diamond\\n      if (oldFacetAddressAndSelectorPosition.facetAddress == address(this)) {\\n        revert CannotRemoveImmutableFunction(selector);\\n      }\\n      // Replace selector with last selector\\n      selectorCount--;\\n      if (oldFacetAddressAndSelectorPosition.selectorPosition != selectorCount) {\\n        bytes4 lastSelector = ds.selectors[selectorCount];\\n        ds.selectors[oldFacetAddressAndSelectorPosition.selectorPosition] = lastSelector;\\n        ds.selectorInfo[lastSelector].selectorPosition = oldFacetAddressAndSelectorPosition.selectorPosition;\\n      }\\n      // Delete last selector\\n      ds.selectors.pop();\\n      delete ds.selectorInfo[selector];\\n    }\\n  }\\n\\n  /// @notice Checks that an address has a non void bytecode\\n  function _enforceHasContractCode(address _contract) private view {\\n    uint256 contractSize;\\n    assembly (\\\"memory-safe\\\") {\\n      contractSize := extcodesize(_contract)\\n    }\\n    if (contractSize == 0) {\\n      revert ContractHasNoCode();\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x10bde4c13cc3d3c4aec15b793565bfe05b5f770eafeb839bfd159dbe6351dc62\",\"license\":\"MIT\"},\"project/contracts/parallelizer/libraries/LibGetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\n\\nimport { LibHelpers } from \\\"./LibHelpers.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibGetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibGetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibGetters.sol\\nlibrary LibGetters {\\n  using Math for uint256;\\n  using SafeCast for uint256;\\n\\n  /// @notice Internal version of the `getCollateralRatio` function with additional return values like `tokens` that\\n  /// is the list of tokens supported by the system, or `balances` which is the amount of each token in `tokens`\\n  /// controlled by the protocol\\n  /// @dev In case some collaterals support external strategies (`isManaged>0`), this list may be bigger\\n  /// than the `collateralList`\\n  /// @dev `subCollateralsTracker` is an array which gives for each collateral asset in the collateral list an\\n  /// accumulator helping to recompute the amount of sub-collateral for each collateral. If the array is:\\n  /// [1,4,5], this means that the collateral with index 1 in the `collateralsList` has 4-1=3 sub-collaterals.\\n  function getCollateralRatio()\\n    internal\\n    view\\n    returns (\\n      uint64 collatRatio,\\n      uint256 stablecoinsIssued,\\n      address[] memory tokens,\\n      uint256[] memory balances,\\n      uint256[] memory subCollateralsTracker\\n    )\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 totalCollateralization;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 collateralListLength = collateralList.length;\\n    uint256 subCollateralsAmount;\\n    // Building the `subCollateralsTracker` array which is useful when later sending the tokens as part of the\\n    // redemption\\n    subCollateralsTracker = new uint256[](collateralListLength);\\n    for (uint256 i; i < collateralListLength; ++i) {\\n      if (ts.collaterals[collateralList[i]].isManaged == 0) ++subCollateralsAmount;\\n      else subCollateralsAmount += ts.collaterals[collateralList[i]].managerData.subCollaterals.length;\\n      subCollateralsTracker[i] = subCollateralsAmount;\\n    }\\n    balances = new uint256[](subCollateralsAmount);\\n    tokens = new address[](subCollateralsAmount);\\n\\n    {\\n      uint256 countCollat;\\n      for (uint256 i; i < collateralListLength; ++i) {\\n        Collateral storage collateral = ts.collaterals[collateralList[i]];\\n        uint256 collateralBalance; // Will be either the balance or the value of assets managed\\n        if (collateral.isManaged > 0) {\\n          // If a collateral is managed, the balances of the sub-collaterals cannot be directly obtained by\\n          // calling `balanceOf` of the sub-collaterals\\n          uint256[] memory subCollateralsBalances;\\n          (subCollateralsBalances, collateralBalance) = LibManager.totalAssets(collateral.managerData.config);\\n          uint256 numSubCollats = subCollateralsBalances.length;\\n          for (uint256 k; k < numSubCollats; ++k) {\\n            tokens[countCollat + k] = address(collateral.managerData.subCollaterals[k]);\\n            balances[countCollat + k] = subCollateralsBalances[k];\\n          }\\n          countCollat += numSubCollats;\\n        } else {\\n          collateralBalance = IERC20(collateralList[i]).balanceOf(address(this));\\n          tokens[countCollat] = collateralList[i];\\n          balances[countCollat++] = collateralBalance;\\n        }\\n        uint256 oracleValue = LibOracle.readRedemption(collateral.oracleConfig);\\n        totalCollateralization += (oracleValue\\n            * LibHelpers.convertDecimalTo(collateralBalance, collateral.decimals, 18, Math.Rounding.Floor)) / BASE_18;\\n      }\\n    }\\n    // The `stablecoinsIssued` value need to be rounded up because it is then used as a divizer when computing\\n    // the `collatRatio`\\n    stablecoinsIssued = uint256(ts.normalizedStables).mulDiv(ts.normalizer, BASE_27, Math.Rounding.Ceil);\\n    if (stablecoinsIssued > 0) {\\n      collatRatio = (totalCollateralization.mulDiv(BASE_9, stablecoinsIssued, Math.Rounding.Ceil)).toUint64();\\n    } else {\\n      collatRatio = type(uint64).max;\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x41690742d2eccc9bcdd914e706c3e0ad203f72284d88bf7bfbaae7c89db23a6d\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibHelpers.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\npragma solidity 0.8.28;\\n\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibHelpers\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibHelpers` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibHelpers.sol\\nlibrary LibHelpers {\\n  /// @notice Rebases the units of `amount` from `fromDecimals` to `toDecimals`\\n  function convertDecimalTo(\\n    uint256 amount,\\n    uint8 fromDecimals,\\n    uint8 toDecimals,\\n    Math.Rounding rounding\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (fromDecimals > toDecimals) {\\n      uint256 divisor = 10 ** (fromDecimals - toDecimals);\\n      return Math.mulDiv(amount, 1, divisor, rounding);\\n    } else if (fromDecimals < toDecimals) {\\n      return amount * 10 ** (toDecimals - fromDecimals);\\n    } else {\\n      return amount;\\n    }\\n  }\\n\\n  /// @notice Checks whether a `token` is in a list `tokens` and returns the index of the token in the list\\n  /// or -1 in the other case\\n  function checkList(address token, address[] memory tokens) internal pure returns (int256) {\\n    uint256 tokensLength = tokens.length;\\n    for (uint256 i; i < tokensLength; ++i) {\\n      if (token == tokens[i]) return int256(i);\\n    }\\n    return -1;\\n  }\\n\\n  /// @notice Searches a sorted `array` and returns the first index that contains a value strictly greater\\n  /// (or lower if increasingArray is false) to `element` minus 1\\n  /// @dev If no such index exists (i.e. all values in the array are strictly lesser/greater than `element`),\\n  /// either array length minus 1, or 0 are returned\\n  /// @dev The time complexity of the search is O(log n).\\n  /// @dev Inspired from OpenZeppelin Contracts v4.4.1:\\n  /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Arrays.sol\\n  /// @dev Modified by Angle Labs to support `uint64`, monotonous arrays and exclusive upper bounds\\n  function findLowerBound(\\n    bool increasingArray,\\n    uint64[] memory array,\\n    uint64 normalizerArray,\\n    uint64 element\\n  )\\n    internal\\n    pure\\n    returns (uint256)\\n  {\\n    if (array.length == 0) {\\n      return 0;\\n    }\\n    uint256 low = 1;\\n    uint256 high = array.length;\\n\\n    if (\\n      (increasingArray && array[high - 1] * normalizerArray <= element)\\n        || (!increasingArray && array[high - 1] * normalizerArray >= element)\\n    ) return high - 1;\\n\\n    while (low < high) {\\n      uint256 mid = Math.average(low, high);\\n\\n      // Note that mid will always be strictly less than high (i.e. it will be a valid array index)\\n      // because Math.average rounds down (it does integer division with truncation).\\n      if (increasingArray ? array[mid] * normalizerArray > element : array[mid] * normalizerArray < element) {\\n        high = mid;\\n      } else {\\n        low = mid + 1;\\n      }\\n    }\\n\\n    // At this point `low` is the exclusive upper bound.\\n    // `low - 1` is the inclusive lower bound.\\n    return low - 1;\\n  }\\n\\n  /// @notice Evaluates for `x` a piecewise linear function defined with the breaking points in the arrays\\n  /// `xArray` and `yArray`\\n  /// @dev The values in the `xArray` must be increasing\\n  function piecewiseLinear(uint64 x, uint64[] memory xArray, int64[] memory yArray) internal pure returns (int64) {\\n    uint256 indexLowerBound = findLowerBound(true, xArray, 1, x);\\n    if (indexLowerBound == 0 && x < xArray[0]) return yArray[0];\\n    else if (indexLowerBound == xArray.length - 1) return yArray[xArray.length - 1];\\n    return yArray[indexLowerBound]\\n      + ((yArray[indexLowerBound + 1] - yArray[indexLowerBound]) * int64(x - xArray[indexLowerBound]))\\n      / int64(xArray[indexLowerBound + 1] - xArray[indexLowerBound]);\\n  }\\n}\\n\",\"keccak256\":\"0x38b35fc8f8bbab2d883236c749de9882262c44162e1da896e2a598cdf52d3f43\",\"license\":\"GPL-3.0\"},\"project/contracts/parallelizer/libraries/LibManager.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IManager } from \\\"contracts/interfaces/IManager.sol\\\";\\n\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibManager\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev Managed collateral assets may be handled through external smart contracts or directly through this library\\n/// @dev There is no implementation at this point for a managed collateral handled through this library, and\\n/// a new specific `ManagerType` would need to be added in this case\\n/// @dev This library is an authorized fork of Angle's `LibManager` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibManager.sol\\nlibrary LibManager {\\n  /// @notice Checks to which address managed funds must be transferred\\n  function transferRecipient(bytes memory config) internal view returns (address recipient) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    recipient = address(this);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (address));\\n  }\\n\\n  /// @notice Performs a transfer of `token` for a collateral that is managed to a `to` address\\n  /// @dev `token` may not be the actual collateral itself, as some collaterals have subcollaterals associated\\n  /// with it\\n  /// @dev Eventually pulls funds from strategies\\n  function release(address token, address to, uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).release(token, to, amount);\\n  }\\n\\n  /// @notice Gets the balances of all the tokens controlled through `managerData`\\n  /// @return balances An array of size `subCollaterals` with current balances of all subCollaterals\\n  /// including the one corresponding to the `managerData` given\\n  /// @return totalValue The value of all the `subCollaterals` in `collateral`\\n  /// @dev `subCollaterals` must always have as first token (index 0) the collateral itself\\n  function totalAssets(bytes memory config) internal view returns (uint256[] memory balances, uint256 totalValue) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).totalAssets();\\n  }\\n\\n  /// @notice Calls a hook if needed after new funds have been transfered to a manager\\n  function invest(uint256 amount, bytes memory config) internal {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) abi.decode(data, (IManager)).invest(amount);\\n  }\\n\\n  /// @notice Returns available underlying tokens, for instance if liquidity is fully used and\\n  /// not withdrawable the function will return 0\\n  function maxAvailable(bytes memory config) internal view returns (uint256 available) {\\n    (ManagerType managerType, bytes memory data) = parseManagerConfig(config);\\n    if (managerType == ManagerType.EXTERNAL) return abi.decode(data, (IManager)).maxAvailable();\\n  }\\n\\n  /// @notice Decodes the `managerData` associated to a collateral\\n  function parseManagerConfig(bytes memory config) internal pure returns (ManagerType managerType, bytes memory data) {\\n    (managerType, data) = abi.decode(config, (ManagerType, bytes));\\n  }\\n}\\n\",\"keccak256\":\"0xbf82c4b1f0f3945fb8efe73d2edb19d01672dad6081288060e43b02eb26fd562\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibOracle.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IParallelizerOracle } from \\\"contracts/interfaces/IParallelizerOracle.sol\\\";\\nimport { AggregatorV3Interface } from \\\"contracts/interfaces/external/chainlink/AggregatorV3Interface.sol\\\";\\nimport { IMorphoOracle } from \\\"contracts/interfaces/external/morpho/IMorphoOracle.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibOracle\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibOracle` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibOracle.sol\\nlibrary LibOracle {\\n  /// @notice Emitted when a MAX target price is ratcheted up by `updateOracle`\\n  event OracleTargetUpdated(address indexed collateral, uint256 previousTarget, uint256 newTarget);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ACTIONS SPECIFIC ORACLES\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads the oracle value used during a redemption to compute collateral ratio for `oracleConfig`\\n  /// @dev This value is only sensitive to compute the collateral ratio and deduce a penalty factor\\n  function readRedemption(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (OracleReadType oracleType, OracleReadType targetType, bytes memory oracleData, bytes memory targetData,) =\\n      _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readRedemption();\\n    } else {\\n      (oracleValue,) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, 0);\\n      return oracleValue;\\n    }\\n  }\\n\\n  /// @notice Reads the oracle value used during mint operations for an asset with `oracleConfig`\\n  /// @dev For assets which do not rely on external oracles, this value is the minimum between the processed oracle\\n  /// value for the asset and its target price\\n  function readMint(bytes memory oracleConfig) internal view returns (uint256 oracleValue) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readMint();\\n    }\\n\\n    (uint128 userDeviation,) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    if (targetPrice < oracleValue) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads the oracle value used for a burn operation for an asset with `oracleConfig`\\n  /// @return oracleValue The actual oracle value obtained\\n  /// @return ratio If `oracle value < target price`, the ratio between the oracle value and the target\\n  /// price, otherwise `BASE_18`\\n  function readBurn(bytes memory oracleConfig) internal view returns (uint256 oracleValue, uint256 ratio) {\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(oracleConfig);\\n    if (oracleType == OracleReadType.EXTERNAL) {\\n      IParallelizerOracle externalOracle = abi.decode(oracleData, (IParallelizerOracle));\\n      return externalOracle.readBurn();\\n    }\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    uint256 targetPrice;\\n    (oracleValue, targetPrice) = readSpotAndTarget(oracleType, targetType, oracleData, targetData, userDeviation);\\n    // Firewall in case the oracle value reported is low compared to the target\\n    // If the oracle value is slightly below its target, then no deviation is reported for the oracle and\\n    // the price of burning the stablecoin for other assets is not impacted. Also, the oracle value of this asset\\n    // is set to the target price, to not be open to direct arbitrage\\n    ratio = BASE_18;\\n    if (oracleValue * BASE_18 < targetPrice * (BASE_18 - burnRatioDeviation)) {\\n      ratio = (oracleValue * BASE_18) / targetPrice;\\n    } else if (oracleValue < targetPrice) {\\n      oracleValue = targetPrice;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    VIEW FUNCTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of the `getOracle` function\\n  function getOracle(address collateral)\\n    internal\\n    view\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return _parseOracleConfig(s.transmuterStorage().collaterals[collateral].oracleConfig);\\n  }\\n\\n  /// @notice Gets the oracle value and the ratio with respect to the target price when it comes to\\n  /// burning for `collateral`\\n  function getBurnOracle(\\n    address collateral,\\n    bytes memory oracleConfig\\n  )\\n    internal\\n    view\\n    returns (uint256 minRatio, uint256 oracleValue)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    minRatio = BASE_18;\\n    address[] memory collateralList = ts.collateralList;\\n    uint256 length = collateralList.length;\\n    for (uint256 i; i < length; ++i) {\\n      uint256 ratioObserved = BASE_18;\\n      if (collateralList[i] != collateral) {\\n        (, ratioObserved) = readBurn(ts.collaterals[collateralList[i]].oracleConfig);\\n      } else {\\n        (oracleValue, ratioObserved) = readBurn(oracleConfig);\\n      }\\n      if (ratioObserved < minRatio) minRatio = ratioObserved;\\n    }\\n  }\\n\\n  /// @notice Computes the `quoteAmount` (for Chainlink oracles) depending on a `quoteType` and a base value\\n  /// (e.g the target price of the asset)\\n  /// @dev For cases where the Chainlink feed directly looks into the value of the asset, `quoteAmount` is `BASE_18`.\\n  /// For others, like wstETH for which Chainlink only has an oracle for stETH, `quoteAmount` is the target price\\n  function quoteAmount(OracleQuoteType quoteType, uint256 baseValue) internal pure returns (uint256) {\\n    if (quoteType == OracleQuoteType.UNIT) return BASE_18;\\n    else return baseValue;\\n  }\\n\\n  function readSpotAndTarget(\\n    OracleReadType oracleType,\\n    OracleReadType targetType,\\n    bytes memory oracleData,\\n    bytes memory targetData,\\n    uint256 deviation\\n  )\\n    internal\\n    view\\n    returns (uint256 oracleValue, uint256 targetPrice)\\n  {\\n    targetPrice = read(targetType, BASE_18, targetData);\\n    oracleValue = read(oracleType, targetPrice, oracleData);\\n    // System may tolerate small deviations from target\\n    // If the oracle value reported is reasonably close to the target\\n    // --> disregard the oracle value and return the target price\\n    if (\\n      targetPrice * (BASE_18 - deviation) < oracleValue * BASE_18\\n        && oracleValue * BASE_18 < targetPrice * (BASE_18 + deviation)\\n    ) oracleValue = targetPrice;\\n  }\\n\\n  /// @notice Reads an oracle value (or a target oracle value) for an asset based on its data parsed `oracleConfig`\\n  function read(OracleReadType readType, uint256 baseValue, bytes memory data) internal view returns (uint256) {\\n    if (readType == OracleReadType.CHAINLINK_FEEDS) {\\n      (\\n        AggregatorV3Interface[] memory circuitChainlink,\\n        uint32[] memory stalePeriods,\\n        uint8[] memory circuitChainIsMultiplied,\\n        uint8[] memory chainlinkDecimals,\\n        OracleQuoteType quoteType\\n      ) = abi.decode(data, (AggregatorV3Interface[], uint32[], uint8[], uint8[], OracleQuoteType));\\n      uint256 quotePrice = quoteAmount(quoteType, baseValue);\\n      uint256 listLength = circuitChainlink.length;\\n      for (uint256 i; i < listLength; ++i) {\\n        quotePrice = readChainlinkFeed(\\n          quotePrice, circuitChainlink[i], circuitChainIsMultiplied[i], chainlinkDecimals[i], stalePeriods[i]\\n        );\\n      }\\n      return quotePrice;\\n    } else if (readType == OracleReadType.STABLE) {\\n      return BASE_18;\\n    } else if (readType == OracleReadType.NO_ORACLE) {\\n      return baseValue;\\n    } else if (readType == OracleReadType.WSTETH) {\\n      return STETH.getPooledEthByShares(1 ether);\\n    } else if (readType == OracleReadType.CBETH) {\\n      return CBETH.exchangeRate();\\n    } else if (readType == OracleReadType.RETH) {\\n      return RETH.getExchangeRate();\\n    } else if (readType == OracleReadType.SFRXETH) {\\n      return SFRXETH.pricePerShare();\\n    } else if (readType == OracleReadType.MAX) {\\n      uint256 maxValue = abi.decode(data, (uint256));\\n      return maxValue;\\n    } else if (readType == OracleReadType.MORPHO_ORACLE) {\\n      (address contractAddress, uint256 normalizationFactor) = abi.decode(data, (address, uint256));\\n      return IMorphoOracle(contractAddress).price() / normalizationFactor;\\n    }\\n    // If the `OracleReadType` is `EXTERNAL`, it means that this function is called to compute a\\n    // `targetPrice` in which case the `baseValue` is returned here\\n    else {\\n      return baseValue;\\n    }\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    SPECIFIC HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Reads a Chainlink feed using a quote amount and converts the quote amount to the out-currency\\n  /// @param _quoteAmount The amount for which to compute the price expressed in `BASE_18`\\n  /// @param feed Chainlink feed to query\\n  /// @param multiplied Whether the ratio outputted by Chainlink should be multiplied or divided to the `quoteAmount`\\n  /// @param decimals Number of decimals of the corresponding Chainlink pair\\n  /// @return The `quoteAmount` converted in out-currency\\n  function readChainlinkFeed(\\n    uint256 _quoteAmount,\\n    AggregatorV3Interface feed,\\n    uint8 multiplied,\\n    uint256 decimals,\\n    uint32 stalePeriod\\n  )\\n    internal\\n    view\\n    returns (uint256)\\n  {\\n    (, int256 ratio,, uint256 updatedAt,) = feed.latestRoundData();\\n    if (ratio <= 0 || block.timestamp - updatedAt > stalePeriod) revert InvalidChainlinkRate();\\n    // Checking whether we should multiply or divide by the ratio computed\\n    if (multiplied == 1) return (_quoteAmount * uint256(ratio)) / (10 ** decimals);\\n    else return (_quoteAmount * (10 ** decimals)) / uint256(ratio);\\n  }\\n\\n  /// @notice Parses an `oracleConfig` into several sub fields\\n  function _parseOracleConfig(bytes memory oracleConfig)\\n    private\\n    pure\\n    returns (OracleReadType, OracleReadType, bytes memory, bytes memory, bytes memory)\\n  {\\n    return abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n  }\\n\\n  /// @notice Seeds the MAX target with the current spot at deployment\\n  /// @dev `updateOracle` bounds each step against the stored target, so a target left at 0 can never be raised\\n  function initializeOracleTarget(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    // Only an unset target may be seeded, so this cannot sidestep the ratchet later on\\n    if (abi.decode(targetData, (uint256)) != 0) revert OracleUpdateFailed();\\n\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n    if (oracleValue == 0) revert OracleUpdateFailed();\\n\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, 0, oracleValue);\\n  }\\n\\n  function updateOracle(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.collaterals[collateral].decimals == 0) revert NotCollateral();\\n\\n    (\\n      OracleReadType oracleType,\\n      OracleReadType targetType,\\n      bytes memory oracleData,\\n      bytes memory targetData,\\n      bytes memory hyperparameters\\n    ) = _parseOracleConfig(ts.collaterals[collateral].oracleConfig);\\n\\n    if (targetType != OracleReadType.MAX) revert OracleUpdateFailed();\\n    uint256 oracleValue = read(oracleType, BASE_18, oracleData);\\n\\n    uint256 maxValue = abi.decode(targetData, (uint256));\\n    // The ratchet is one-way and only governance can lower the target again through `setOracle`, so a single\\n    // update is bounded: a transient upward print cannot be locked in beyond `MAX_ORACLE_RATCHET_STEP`\\n    if (oracleValue <= maxValue || oracleValue * BASE_18 > maxValue * (BASE_18 + MAX_ORACLE_RATCHET_STEP)) {\\n      revert OracleUpdateFailed();\\n    }\\n    ts.collaterals[collateral].oracleConfig =\\n      abi.encode(oracleType, targetType, oracleData, abi.encode(oracleValue), hyperparameters);\\n    emit OracleTargetUpdated(collateral, maxValue, oracleValue);\\n  }\\n}\\n\",\"keccak256\":\"0x60e54568d2d7398c6a5ab8c40eb3cb59d7851794292dd54420998cfaffc9ab3e\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSetters.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { SafeCast } from \\\"@openzeppelin/contracts/utils/math/SafeCast.sol\\\";\\nimport { IERC20Metadata } from \\\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\\\";\\n\\nimport { LibSurplus } from \\\"./LibSurplus.sol\\\";\\nimport { LibManager } from \\\"./LibManager.sol\\\";\\nimport { LibOracle } from \\\"./LibOracle.sol\\\";\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\nimport { LibDiamond } from \\\"./LibDiamond.sol\\\";\\nimport { LibWhitelist } from \\\"./LibWhitelist.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSetters\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibSetters` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibSetters.sol\\nlibrary LibSetters {\\n  using SafeCast for uint256;\\n\\n  event CollateralAdded(address indexed collateral);\\n  event CollateralManagerSet(address indexed collateral, ManagerStorage managerData);\\n  event CollateralRevoked(address indexed collateral);\\n  event CollateralWhitelistStatusUpdated(address indexed collateral, bytes whitelistData, uint8 whitelistStatus);\\n  event FeesSet(address indexed collateral, uint64[] xFee, int64[] yFee, bool mint);\\n  event OracleSet(address indexed collateral, bytes oracleConfig);\\n  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n  event PauseToggled(address indexed collateral, uint256 pausedType, bool isPaused);\\n  event RedemptionCurveParamsSet(uint64[] xFee, int64[] yFee);\\n  event ReservesAdjusted(address indexed collateral, uint256 amount, bool increase);\\n  event StablecoinCapSet(address indexed collateral, uint256 stablecoinCap);\\n  event TrustedToggled(address indexed sender, bool isTrusted, TrustedType trustedType);\\n  event WhitelistStatusToggled(WhitelistType whitelistType, address indexed who, uint256 whitelistStatus);\\n  event PayeeAdded(address indexed payee, uint256 shares);\\n  event SlippageToleranceUpdated(address indexed collateral, uint256 slippageTolerance);\\n  event SurplusBufferRatioUpdated(uint64 surplusBufferRatio);\\n  event SwapRouterUpdated(address indexed swapRouter);\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GOVERNOR ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `setAccessManager`\\n  function setAccessManager(IAccessManager _newAccessManager) internal {\\n    if (address(_newAccessManager).code.length == 0) revert InvalidAccessManager();\\n    DiamondStorage storage ds = s.diamondStorage();\\n    address previousAccessManager = address(ds.accessManager);\\n    ds.accessManager = _newAccessManager;\\n    emit OwnershipTransferred(previousAccessManager, address(_newAccessManager));\\n  }\\n\\n  /// @notice Internal version of `setCollateralManager`\\n  function setCollateralManager(\\n    address collateral,\\n    bool checkExternalManagerBalance,\\n    ManagerStorage memory managerData\\n  )\\n    internal\\n  {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    if (managerData.config.length != 0) {\\n      // The first subCollateral given should be the actual collateral asset\\n      if (address(managerData.subCollaterals[0]) != collateral) revert InvalidParams();\\n      // Sanity check on the manager data that is passed\\n      LibManager.parseManagerConfig(managerData.config);\\n      collatInfo.isManaged = 1;\\n    } else {\\n      collatInfo.isManaged = 0;\\n    }\\n    collatInfo.managerData = managerData;\\n    emit CollateralManagerSet(collateral, managerData);\\n  }\\n\\n  /// @notice Internal version of `toggleTrusted`\\n  function toggleTrusted(address sender, TrustedType t) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 trustedStatus;\\n    if (t == TrustedType.Updater) {\\n      trustedStatus = 1 - ts.isTrusted[sender];\\n      ts.isTrusted[sender] = trustedStatus;\\n    } else {\\n      trustedStatus = 1 - ts.isSellerTrusted[sender];\\n      ts.isSellerTrusted[sender] = trustedStatus;\\n    }\\n    emit TrustedToggled(sender, trustedStatus == 1, t);\\n  }\\n\\n  /// @notice Internal version of `addCollateral`\\n  function addCollateral(address collateral) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals != 0) revert AlreadyAdded();\\n    collatInfo.decimals = uint8(IERC20Metadata(collateral).decimals());\\n    ts.collateralList.push(collateral);\\n    emit CollateralAdded(collateral);\\n  }\\n\\n  /// @notice Internal version of `adjustStablecoins`\\n  function adjustStablecoins(address collateral, uint128 amount, bool increase) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    uint128 normalizedAmount = ((amount * BASE_27) / ts.normalizer).toUint128();\\n    if (increase) {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables + uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables + normalizedAmount;\\n      if (uint256(collatInfo.normalizedStables) * uint256(ts.normalizer) / BASE_27 > collatInfo.stablecoinCap) {\\n        revert AboveCap();\\n      }\\n    } else {\\n      collatInfo.normalizedStables = collatInfo.normalizedStables - uint216(normalizedAmount);\\n      ts.normalizedStables = ts.normalizedStables - normalizedAmount;\\n    }\\n    emit ReservesAdjusted(collateral, amount, increase);\\n  }\\n\\n  /// @notice Internal version of `revokeCollateral`\\n  function revokeCollateral(address collateral, bool checkExternalManagerBalance) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (collatInfo.normalizedStables > 0) revert CollateralBacked();\\n    uint8 isManaged = collatInfo.isManaged;\\n    if (isManaged > 0 && checkExternalManagerBalance) {\\n      (, uint256 totalValue) = LibManager.totalAssets(collatInfo.managerData.config);\\n      if (totalValue > 0) revert ManagerHasAssets();\\n    }\\n    delete ts.collaterals[collateral];\\n    address[] memory collateralListMem = ts.collateralList;\\n    uint256 length = collateralListMem.length;\\n    for (uint256 i; i < length - 1; ++i) {\\n      if (collateralListMem[i] == collateral) {\\n        ts.collateralList[i] = collateralListMem[length - 1];\\n        break;\\n      }\\n    }\\n    ts.collateralList.pop();\\n    emit CollateralRevoked(collateral);\\n  }\\n\\n  /// @notice Internal version of `setOracle`\\n  function setOracle(address collateral, bytes memory oracleConfig) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    (,,,, bytes memory hyperparameters) =\\n      abi.decode(oracleConfig, (OracleReadType, OracleReadType, bytes, bytes, bytes));\\n    (uint128 userDeviation, uint128 burnRatioDeviation) = abi.decode(hyperparameters, (uint128, uint128));\\n    if (userDeviation > burnRatioDeviation) revert InvalidParams();\\n    // Checks oracle validity\\n    LibOracle.readMint(oracleConfig);\\n    collatInfo.oracleConfig = oracleConfig;\\n    emit OracleSet(collateral, oracleConfig);\\n  }\\n\\n  /// @notice Internal version of `setWhitelistStatus`\\n  function setWhitelistStatus(address collateral, uint8 whitelistStatus, bytes memory whitelistData) internal {\\n    if (whitelistStatus > 1) revert InvalidWhitelistStatus();\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    if (whitelistStatus == 1) {\\n      // Sanity check\\n      LibWhitelist.checkWhitelist(whitelistData, address(this));\\n      collatInfo.whitelistData = whitelistData;\\n    } else {\\n      // If whitelist is revoked, clear the whitelist data\\n      collatInfo.whitelistData = \\\"\\\";\\n    }\\n    collatInfo.onlyWhitelisted = whitelistStatus;\\n    emit CollateralWhitelistStatusUpdated(collateral, collatInfo.whitelistData, whitelistStatus);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    ONLY GUARDIAN ACTIONS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Internal version of `pause` \\u2014 sets the action's live flag to `0`\\n  /// @dev Reverts with `AlreadyPaused` if the action is already paused so a no-op governance\\n  /// call cannot pass silently\\n  function pause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 0);\\n  }\\n\\n  /// @notice Internal version of `unpause` \\u2014 sets the action's live flag to `1`\\n  /// @dev Reverts with `NotPaused` if the action is already unpaused so a no-op governance\\n  /// call cannot pass silently\\n  function unpause(address collateral, ActionType action) internal {\\n    _setPauseState(collateral, action, 1);\\n  }\\n\\n  /// @dev Shared accessor for `pause` and `unpause`. `targetIsLive` is `0` to pause and `1`\\n  /// to unpause. Reverts on no-op transitions.\\n  function _setPauseState(address collateral, ActionType action, uint8 targetIsLive) private {\\n    if (action == ActionType.Mint || action == ActionType.Burn) {\\n      Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n      if (collatInfo.decimals == 0) revert NotCollateral();\\n      uint8 currentIsLive = action == ActionType.Mint ? collatInfo.isMintLive : collatInfo.isBurnLive;\\n      if (currentIsLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      if (action == ActionType.Mint) {\\n        collatInfo.isMintLive = targetIsLive;\\n      } else {\\n        collatInfo.isBurnLive = targetIsLive;\\n      }\\n    } else {\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      if (ts.isRedemptionLive == targetIsLive) {\\n        if (targetIsLive == 0) revert AlreadyPaused();\\n        revert NotPaused();\\n      }\\n      ts.isRedemptionLive = targetIsLive;\\n    }\\n    emit PauseToggled(collateral, uint256(action), targetIsLive == 0);\\n  }\\n\\n  /// @notice Internal version of `setFees`\\n  function setFees(address collateral, uint64[] memory xFee, int64[] memory yFee, bool mint) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    checkFees(xFee, yFee, mint ? ActionType.Mint : ActionType.Burn);\\n    if (mint) {\\n      collatInfo.xFeeMint = xFee;\\n      collatInfo.yFeeMint = yFee;\\n    } else {\\n      collatInfo.xFeeBurn = xFee;\\n      collatInfo.yFeeBurn = yFee;\\n    }\\n    emit FeesSet(collateral, xFee, yFee, mint);\\n  }\\n\\n  /// @notice Internal version of `setRedemptionCurveParams`\\n  function setRedemptionCurveParams(uint64[] memory xFee, int64[] memory yFee) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    LibSetters.checkFees(xFee, yFee, ActionType.Redeem);\\n    ts.xRedemptionCurve = xFee;\\n    ts.yRedemptionCurve = yFee;\\n    emit RedemptionCurveParamsSet(xFee, yFee);\\n  }\\n\\n  /// @notice Internal version of `toggleWhitelist`\\n  function toggleWhitelist(WhitelistType whitelistType, address who) internal {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    uint256 whitelistStatus = 1 - ts.isWhitelistedForType[whitelistType][who];\\n    ts.isWhitelistedForType[whitelistType][who] = whitelistStatus;\\n    emit WhitelistStatusToggled(whitelistType, who, whitelistStatus);\\n  }\\n\\n  /// @notice Sets the stablecoin cap that can be issued from a collateral\\n  function setStablecoinCap(address collateral, uint256 stablecoinCap) internal {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.decimals == 0) revert NotCollateral();\\n    collatInfo.stablecoinCap = stablecoinCap;\\n    emit StablecoinCapSet(collateral, stablecoinCap);\\n  }\\n\\n  /// @notice Internal version of `updatePayees`\\n  function updatePayees(address[] memory _payees, uint256[] memory _shares, bool _skipRelease) internal {\\n    if (_payees.length == 0 || _payees.length > MAX_PAYEES) revert InvalidLengths();\\n    if (_payees.length != _shares.length) revert ArrayLengthMismatch();\\n    /// @dev Distribute the fees before updating the fee receivers.\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (!_skipRelease) {\\n      uint256 income = ts.tokenP.balanceOf(address(this));\\n      if (income > 0 && ts.payees.length > 0) {\\n        LibSurplus.release(income, ts.payees);\\n      }\\n    }\\n\\n    // Zero out stale shares for old payees\\n    uint256 i = 0;\\n    for (; i < ts.payees.length; ++i) {\\n      ts.shares[ts.payees[i]] = 0;\\n    }\\n    delete ts.payees;\\n    uint256 _totalShares = 0;\\n    i = 0;\\n    for (; i < _payees.length; ++i) {\\n      for (uint256 j = 0; j < i; ++j) {\\n        if (_payees[j] == _payees[i]) revert AlreadyAdded();\\n      }\\n      _totalShares += _addPayee(_payees[i], _shares[i]);\\n    }\\n    ts.totalShares = _totalShares;\\n  }\\n\\n  /// @notice Internal version of `updateSlippageTolerance`\\n  function updateSlippageTolerance(address collateral, uint256 slippageTolerance) internal {\\n    if (slippageTolerance > BASE_9) revert InvalidRate();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.slippageTolerance[collateral] = slippageTolerance;\\n    emit SlippageToleranceUpdated(collateral, slippageTolerance);\\n  }\\n\\n  /// @notice Internal version of `setSwapRouter`\\n  function setSwapRouter(address swapRouter) internal {\\n    if (swapRouter == address(0)) revert ZeroAddress();\\n    s.transmuterStorage().swapRouter = swapRouter;\\n    emit SwapRouterUpdated(swapRouter);\\n  }\\n\\n  /// @notice Internal version of `updateSurplusBufferRatio`\\n  function updateSurplusBufferRatio(uint64 _surplusBufferRatio) internal {\\n    if (_surplusBufferRatio < uint64(BASE_9)) revert InvalidParam();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.surplusBufferRatio = _surplusBufferRatio;\\n    emit SurplusBufferRatioUpdated(_surplusBufferRatio);\\n  }\\n\\n  /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n    HELPERS\\n  //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n  /// @notice Checks the fee values given for the `mint`, `burn`, and `redeem` functions\\n  function checkFees(uint64[] memory xFee, int64[] memory yFee, ActionType action) internal view {\\n    uint256 n = xFee.length;\\n    if (n != yFee.length || n == 0) revert InvalidParams();\\n    if (\\n      // Mint inflexion points should be in [0,BASE_9[\\n      // We have: amountPostFee * (BASE_9 + yFeeMint) = amountPreFee * BASE_9\\n      // Hence we consider BASE_12 as the max value (100% fees) for yFeeMint\\n      // Burn inflexion points should be in [0,BASE_9] but fees should be constant in\\n      // the first segment [BASE_9, x_{n-1}[\\n      // Redemption inflexion points should be in [0,BASE_9]\\n      (action == ActionType.Mint && (xFee[n - 1] >= BASE_9 || xFee[0] != 0 || yFee[n - 1] > int256(BASE_12)))\\n        || (action == ActionType.Burn\\n          && (xFee[0] != BASE_9 || yFee[n - 1] > int256(BASE_9) || (n > 1 && (yFee[0] != yFee[1]))))\\n        || (action == ActionType.Redeem && (xFee[n - 1] > BASE_9 || yFee[n - 1] < 0 || yFee[n - 1] > int256(BASE_9)))\\n    ) {\\n      revert InvalidParams();\\n    }\\n\\n    for (uint256 i; i < n - 1; ++i) {\\n      if (\\n        // xFee strictly increasing and yFee increasing for mints\\n        // xFee strictly decreasing and yFee increasing for burns\\n        // xFee strictly increasing and yFee should be in [0,BASE_9] for redemptions\\n        (action == ActionType.Mint && (xFee[i] >= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Burn && (xFee[i] <= xFee[i + 1] || (yFee[i + 1] < yFee[i])))\\n          || (action == ActionType.Redeem && (xFee[i] >= xFee[i + 1] || yFee[i] < 0 || yFee[i] > int256(BASE_9)))\\n      ) revert InvalidParams();\\n    }\\n\\n    // If a mint or burn fee is negative, we need to check that accounts atomically minting\\n    // (from any collateral) and then burning cannot get more than their initial value\\n    if (yFee[0] < 0) {\\n      if (!LibDiamond.isGovernor(msg.sender)) revert NotGovernor(); // Only governor can set negative fees\\n      ParallelizerStorage storage ts = s.transmuterStorage();\\n      address[] memory collateralListMem = ts.collateralList;\\n      uint256 length = collateralListMem.length;\\n      if (action == ActionType.Mint) {\\n        // This can be mathematically expressed by `(1-min_c(burnFee_c))<=(1+mintFee[0])`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory burnFees = ts.collaterals[collateralListMem[i]].yFeeBurn;\\n          if (burnFees[0] + yFee[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n      if (action == ActionType.Burn) {\\n        // This can be mathematically expressed by `(1-burnFee[0])<=(1+min_c(mintFee_c))`\\n        for (uint256 i; i < length; ++i) {\\n          int64[] memory mintFees = ts.collaterals[collateralListMem[i]].yFeeMint;\\n          if (yFee[0] + mintFees[0] < 0) revert InvalidNegativeFees();\\n        }\\n      }\\n    }\\n  }\\n\\n  /// @notice Add a new fee receiver.\\n  /// @param _payee The address of the fee receiver.\\n  /// @param _shares The number of shares assigned to the fee receiver.\\n  function _addPayee(address _payee, uint256 _shares) internal returns (uint256) {\\n    if (_shares == 0) revert ZeroAmount();\\n    // The Parallelizer holds the income being distributed, so a share allocated to itself is handed\\n    // back to `release` as fresh income on the next call. `address(0)` stays valid: `LibSurplus`\\n    // treats it as the sentinel for burning that share.\\n    if (_payee == address(this)) revert InvalidPayee();\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n\\n    ts.payees.push(_payee);\\n    ts.shares[_payee] = _shares;\\n    emit PayeeAdded(_payee, _shares);\\n    return _shares;\\n  }\\n}\\n\",\"keccak256\":\"0x45ed1863aec8d20f3659d2b0ea657b629b5c33b71f895ae6775ea72156203197\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibStorage.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport { DiamondStorage, ImplementationStorage, ParallelizerStorage } from \\\"../Storage.sol\\\";\\n\\n/// @title LibStorage\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibStorage` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibStorage.sol\\nlibrary LibStorage {\\n  /// @notice Returns the storage struct stored at the `DIAMOND_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic of the different facets used in the diamond proxy\\n  function diamondStorage() internal pure returns (DiamondStorage storage ds) {\\n    bytes32 position = DIAMOND_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ds.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `TRANSMUTER_STORAGE_POSITION` slot\\n  /// @dev This struct handles the particular logic of the Parallelizer system\\n  function transmuterStorage() internal pure returns (ParallelizerStorage storage ts) {\\n    bytes32 position = TRANSMUTER_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ts.slot := position\\n    }\\n  }\\n\\n  /// @notice Returns the storage struct stored at the `IMPLEMENTATION_STORAGE_POSITION` slot\\n  /// @dev This struct handles the logic for making the contract easily usable on Etherscan\\n  function implementationStorage() internal pure returns (ImplementationStorage storage ims) {\\n    bytes32 position = IMPLEMENTATION_STORAGE_POSITION;\\n    assembly (\\\"memory-safe\\\") {\\n      ims.slot := position\\n    }\\n  }\\n}\\n\",\"keccak256\":\"0x081108bb060800509deb24387ffd0199a3f93f933c3f59c8fc14eb536790fe04\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibSurplus.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IERC20 } from \\\"@openzeppelin/contracts/interfaces/IERC20.sol\\\";\\nimport { SafeERC20 } from \\\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\\\";\\nimport { Math } from \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\n\\nimport { LibManager } from \\\"../libraries/LibManager.sol\\\";\\nimport { LibOracle } from \\\"../libraries/LibOracle.sol\\\";\\nimport { LibGetters } from \\\"../libraries/LibGetters.sol\\\";\\nimport { LibHelpers } from \\\"../libraries/LibHelpers.sol\\\";\\nimport { LibStorage as s } from \\\"../libraries/LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Constants.sol\\\";\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibSurplus\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\nlibrary LibSurplus {\\n  using SafeERC20 for IERC20;\\n  using Math for uint256;\\n\\n  event IncomeReleased(uint256 income, uint256 releasedAt);\\n  event IncomeReleasedToPayee(uint256 income, address payee, uint256 releasedAt);\\n\\n  /// @notice Internal version of `release`\\n  function release(\\n    uint256 _incomeToRelease,\\n    address[] memory _payees\\n  )\\n    internal\\n    returns (address[] memory payees, uint256[] memory amounts)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    ts.lastReleasedAt = block.timestamp;\\n    uint256 i;\\n    amounts = new uint256[](_payees.length);\\n    for (; i < _payees.length; ++i) {\\n      address payee = _payees[i];\\n      amounts[i] = _release(_incomeToRelease, payee, ts);\\n    }\\n\\n    emit IncomeReleased(_incomeToRelease, ts.lastReleasedAt);\\n    return (_payees, amounts);\\n  }\\n\\n  /// @notice Internal function to release a percentage of income to a specific payee.\\n  /// @dev uses totalShares to calculate correct share.\\n  /// @param _totalIncomeReceived Total income for all payees, will be split according to shares.\\n  /// @param _payee The address of the payee to whom to distribute the fees.\\n  /// @param _ts The contract storage.\\n  /// @return income The amount transfer to the payee.\\n  function _release(\\n    uint256 _totalIncomeReceived,\\n    address _payee,\\n    ParallelizerStorage storage _ts\\n  )\\n    internal\\n    returns (uint256 income)\\n  {\\n    income = _totalIncomeReceived.mulDiv(_ts.shares[_payee], _ts.totalShares);\\n    if (_payee == address(0)) {\\n      _ts.tokenP.burnSelf(income, address(this));\\n    } else {\\n      IERC20(address(_ts.tokenP)).safeTransfer(_payee, income);\\n    }\\n    emit IncomeReleasedToPayee(income, _payee, _ts.lastReleasedAt);\\n  }\\n\\n  /// @notice Computes the surplus of a collateral.\\n  /// @param collateral The collateral address to compute the surplus of.\\n  /// @return collateralSurplus The collateral surplus amount.\\n  /// @return stableSurplus The surplus in stable amount.\\n  function _computeCollateralSurplus(address collateral)\\n    internal\\n    view\\n    returns (uint256 collateralSurplus, uint256 stableSurplus)\\n  {\\n    ParallelizerStorage storage ts = s.transmuterStorage();\\n    if (ts.surplusBufferRatio == 0) revert SurplusBufferRatioNotSet();\\n    Collateral storage collatInfo = ts.collaterals[collateral];\\n    uint256 collateralBalance = _getCollateralBalance(collateral);\\n    uint256 redemptionValue = LibOracle.readRedemption(collatInfo.oracleConfig);\\n    uint256 mintValue = LibOracle.readMint(collatInfo.oracleConfig);\\n    // Use the lower oracle value to conservatively size the surplus, preventing over-extraction\\n    // that would cause the post-swap CR check (which uses readRedemption) to revert\\n    uint256 totalCollateralValue = LibHelpers.convertDecimalTo(\\n      Math.min(redemptionValue, mintValue) * collateralBalance, 18 + collatInfo.decimals, 18, Math.Rounding.Floor\\n    );\\n    uint256 stablesBacked = (uint256(collatInfo.normalizedStables) * ts.normalizer) / BASE_27;\\n    // Compute the max stables that can be backed while maintaining the buffer ratio\\n    uint256 maxBackable = (totalCollateralValue * BASE_9) / ts.surplusBufferRatio;\\n    if (maxBackable <= stablesBacked) revert ZeroSurplusAmount();\\n    stableSurplus = maxBackable - stablesBacked;\\n    // Cap per-collateral surplus by global extractable surplus\\n    stableSurplus = Math.min(stableSurplus, _calculateGlobalExtractableSurplus(ts.surplusBufferRatio));\\n    if (stableSurplus == 0) revert ZeroSurplusAmount();\\n    collateralSurplus =\\n      LibHelpers.convertDecimalTo((stableSurplus * BASE_18) / mintValue, 18, collatInfo.decimals, Math.Rounding.Floor);\\n  }\\n\\n  /// @notice Computes the global extractable surplus above the surplus buffer ratio.\\n  /// @param surplusBufferRatio The surplus buffer ratio.\\n  /// @return globalStableSurplus The maximum stables that can be minted globally while maintaining the buffer ratio.\\n  function _calculateGlobalExtractableSurplus(uint64 surplusBufferRatio)\\n    internal\\n    view\\n    returns (uint256 globalStableSurplus)\\n  {\\n    (uint64 collatRatio, uint256 stablecoinsIssued,,,) = LibGetters.getCollateralRatio();\\n    if (collatRatio <= surplusBufferRatio) revert ZeroSurplusAmount();\\n    globalStableSurplus = stablecoinsIssued * (uint256(collatRatio) - surplusBufferRatio) / surplusBufferRatio;\\n  }\\n\\n  /// @notice Gets the balance of a collateral.\\n  /// @dev If the collateral is managed, the balance is the total assets of the managed collateral.\\n  /// @param collateral The collateral address to get the balance of.\\n  /// @return balance The balance of the collateral.\\n  function _getCollateralBalance(address collateral) internal view returns (uint256 balance) {\\n    Collateral storage collatInfo = s.transmuterStorage().collaterals[collateral];\\n    if (collatInfo.isManaged > 0) {\\n      (, balance) = LibManager.totalAssets(collatInfo.managerData.config);\\n    } else {\\n      balance = IERC20(collateral).balanceOf(address(this));\\n    }\\n  }\\n\\n  /// @notice Computes the minimum expected amount of stablecoins to receive for a given surplus.\\n  /// @param stableSurplus The surplus in stable amount.\\n  /// @param slippageTolerance The slippage tolerance.\\n  /// @return minExpectedAmount The minimum expected amount of stablecoins to receive.\\n  function _minExpectedAmount(\\n    uint256 stableSurplus,\\n    uint256 slippageTolerance\\n  )\\n    internal\\n    pure\\n    returns (uint256 minExpectedAmount)\\n  {\\n    return (stableSurplus * (BASE_9 - slippageTolerance)) / BASE_9;\\n  }\\n}\\n\",\"keccak256\":\"0x7e475b445fab889d5aa9cbb19f6e5157e6d5f16af053a1202fadbeb89d123a79\",\"license\":\"BUSL-1.1\"},\"project/contracts/parallelizer/libraries/LibWhitelist.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { IKeyringGuard } from \\\"contracts/interfaces/external/keyring/IKeyringGuard.sol\\\";\\n\\nimport { LibStorage as s } from \\\"./LibStorage.sol\\\";\\n\\nimport \\\"../../utils/Errors.sol\\\";\\nimport \\\"../Storage.sol\\\";\\n\\n/// @title LibWhitelist\\n/// @author Cooper Labs\\n/// @custom:contact security@cooperlabs.xyz\\n/// @dev This library is an authorized fork of Angle's `LibWhitelist` library\\n/// https://github.com/AngleProtocol/angle-transmuter/blob/main/contracts/transmuter/libraries/LibWhitelist.sol\\nlibrary LibWhitelist {\\n  /// @notice Checks whether `sender` is whitelisted for a collateral with `whitelistData`\\n  function checkWhitelist(bytes memory whitelistData, address sender) internal returns (bool) {\\n    (WhitelistType whitelistType, bytes memory data) = abi.decode(whitelistData, (WhitelistType, bytes));\\n    if (s.transmuterStorage().isWhitelistedForType[whitelistType][sender] > 0) return true;\\n    if (data.length != 0) {\\n      if (whitelistType == WhitelistType.BACKED) {\\n        address keyringGuard = abi.decode(data, (address));\\n        if (keyringGuard != address(0)) return IKeyringGuard(keyringGuard).isAuthorized(address(this), sender);\\n      }\\n    }\\n    return false;\\n  }\\n}\\n\",\"keccak256\":\"0x03e1552a11a9cfdfe83ad4d90111a72c44fa204a90b37cb19cbba185a04addc7\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Constants.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nimport { ICbETH } from \\\"contracts/interfaces/external/coinbase/ICbETH.sol\\\";\\nimport { ISfrxETH } from \\\"contracts/interfaces/external/frax/ISfrxETH.sol\\\";\\nimport { IStETH } from \\\"contracts/interfaces/external/lido/IStETH.sol\\\";\\nimport { IRETH } from \\\"contracts/interfaces/external/rocketPool/IRETH.sol\\\";\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                 STORAGE SLOTS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n/// @dev Storage position of `DiamondStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.diamond.storage\\\") - 1`\\nbytes32 constant DIAMOND_STORAGE_POSITION = 0xc8fcad8db84d3cc18b4c41d551ea0ee66dd599cde068d998e57d5e09332c131b;\\n\\n/// @dev Storage position of `ParallelizerStorage` structure\\n/// @dev Equals `keccak256(\\\"diamond.standard.parallelizer.storage\\\") - 1`\\nbytes32 constant TRANSMUTER_STORAGE_POSITION = 0x4b2dd303f68b99d244b702089c802b6e9ea1b5d4ef61fd436d6c41abb1178c75;\\n\\n/// @dev Storage position of `ImplementationStorage` structure\\n/// @dev Equals `keccak256(\\\"eip1967.proxy.implementation\\\") - 1`\\nbytes32 constant IMPLEMENTATION_STORAGE_POSITION = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     MATHS\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\nuint256 constant BASE_6 = 1e6;\\nuint256 constant BASE_8 = 1e8;\\nuint256 constant BASE_9 = 1e9;\\nuint256 constant BASE_12 = 1e12;\\nuint256 constant BPS = 1e14;\\nuint256 constant BASE_18 = 1e18;\\nuint256 constant HALF_BASE_27 = 1e27 / 2;\\nuint256 constant BASE_27 = 1e27;\\nuint256 constant BASE_36 = 1e36;\\nuint256 constant MAX_BURN_FEE = 999_000_000;\\nuint256 constant MAX_MINT_FEE = BASE_12 - 1;\\nuint256 constant MAX_PAYEES = 10;\\nuint256 constant SECONDS_PER_YEAR = 365 days;\\nuint256 constant MAX_STORED_ASSETS_INIT_STALENESS = 30 minutes;\\n/// @dev Largest relative increase a single `updateOracle` ratchet may apply to a MAX target price\\nuint256 constant MAX_ORACLE_RATCHET_STEP = 5e16;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// The values being non-zero value makes deployment a bit more expensive,\\n// but in exchange the refund on every call to nonReentrant will be lower in\\n// amount. Since refunds are capped to a percentage of the total\\n// transaction's gas, it is best to keep them low in cases like this one, to\\n// increase the likelihood of the full refund coming into effect.\\nuint8 constant NOT_ENTERED = 1;\\nuint8 constant ENTERED = 2;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                                     REENTRANT\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\n// Role IDs for the AccessManager\\nuint64 constant GOVERNOR_ROLE = 10;\\nuint64 constant GUARDIAN_ROLE = 20;\\nuint64 constant KEEPER_ROLE = 30;\\n\\n/*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////\\n                                               COMMON ADDRESSES\\n//////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/\\n\\naddress constant PERMIT_2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\\nICbETH constant CBETH = ICbETH(0xBe9895146f7AF43049ca1c1AE358B0541Ea49704);\\nIRETH constant RETH = IRETH(0xae78736Cd615f374D3085123A210448E74Fc6393);\\nIStETH constant STETH = IStETH(0xae7ab96520DE3A18E5e111B5EaAb095312D7fE84);\\nISfrxETH constant SFRXETH = ISfrxETH(0xac3E018457B222d93114458476f3E3416Abbe38F);\\naddress constant XEVT = 0x3Ee320c9F73a84D1717557af00695A34b26d1F1d;\\naddress constant USDM = 0x59D9356E565Ab3A36dD77763Fc0d87fEaf85508C;\\naddress constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;\\naddress constant EURC = 0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c;\\n\",\"keccak256\":\"0x8cf10b94d5483565f19c16e527c5e23b0a41f8065d8245c904be5d91ad5b2c03\",\"license\":\"BUSL-1.1\"},\"project/contracts/utils/Errors.sol\":{\"content\":\"// SPDX-License-Identifier: BUSL-1.1\\npragma solidity 0.8.28;\\n\\nerror AboveCap();\\nerror AccessManagedUnauthorized(address caller);\\nerror AlreadyAdded();\\nerror ArrayLengthMismatch();\\nerror AuthorizationTransferMismatch();\\nerror CannotAddFunctionToDiamondThatAlreadyExists(bytes4 _selector);\\nerror CannotAddSelectorsToZeroAddress(bytes4[] _selectors);\\nerror CannotRemoveFunctionThatDoesNotExist(bytes4 _selector);\\nerror CannotRemoveImmutableFunction(bytes4 _selector);\\nerror CannotReplaceFunctionsFromFacetWithZeroAddress(bytes4[] _selectors);\\nerror CannotReplaceFunctionThatDoesNotExists(bytes4 _selector);\\nerror CannotReplaceFunctionWithTheSameFunctionFromTheSameFacet(bytes4 _selector);\\nerror CannotReplaceImmutableFunction(bytes4 _selector);\\nerror ContractHasNoCode();\\nerror CollateralBacked();\\nerror CannotBurnAllStableIssued();\\nerror FunctionNotFound(bytes4 _functionSelector);\\nerror IncorrectFacetCutAction(uint8 _action);\\nerror InitializationFunctionReverted(address _initializationContractAddress, bytes _calldata);\\nerror InvalidChainlinkRate();\\nerror InvalidLengths();\\nerror InvalidNegativeFees();\\nerror InvalidOracleType();\\nerror InvalidParam();\\nerror InvalidParams();\\nerror InvalidPayee();\\nerror InvalidRate();\\nerror InvalidSwap();\\nerror InvalidTokens();\\nerror InvalidAccessManager();\\nerror InvalidWhitelistStatus();\\nerror ManagerHasAssets();\\nerror NoSelectorsProvidedForFacetForCut(address _facetAddress);\\nerror NotAllowed();\\nerror NotCollateral();\\nerror NotGovernor();\\nerror NotGuardian();\\nerror NotTrusted();\\nerror NotTrustedOrGuardian();\\nerror NotWhitelisted();\\nerror RewardSwapFailed();\\nerror OracleUpdateFailed();\\nerror SurplusBufferRatioNotSet();\\nerror Paused();\\nerror AlreadyPaused();\\nerror NotPaused();\\nerror ReentrantCall();\\nerror RemoveFacetAddressMustBeZeroAddress(address _facetAddress);\\nerror TooBigAmountIn();\\nerror TooLate();\\nerror TooSmallAmountOut();\\nerror UnexpectedRedemptionTokens();\\nerror ZeroAddress();\\nerror ZeroAmount();\\nerror ZeroSurplusAmount();\\nerror SwapError();\\nerror SlippageTooHigh();\\nerror InsufficientFunds();\\nerror Undercollateralized();\\nerror StaleAccrual();\\nerror NotInitialized();\\n\",\"keccak256\":\"0xc163f0995069ae58c8eb66225c1a4df84e94049b8bc6ff2fed348c3af4fcabaa\",\"license\":\"BUSL-1.1\"}},\"version\":1}",
   "storageLayout": {
     "storage": [],
     "types": null
   },
   "userdoc": {
+    "events": {
+      "OracleTargetUpdated(address,uint256,uint256)": {
+        "notice": "Emitted when a MAX target price is ratcheted up by `updateOracle`"
+      }
+    },
     "kind": "user",
     "methods": {
       "addCollateral(address)": {
@@ -836,6 +906,9 @@
       "setOracle(address,bytes)": {
         "notice": "Sets the `oracleConfig` used to read the value of `collateral` for the mint, burn and redemption operations"
       },
+      "setSwapRouter(address)": {
+        "notice": "Sets the aggregator or DEX the `RewardHandler` forwards its swap payload to"
+      },
       "setWhitelistStatus(address,uint8,bytes)": {
         "notice": "Changes whether a `collateral` can only be handled during burns and redemptions by whitelisted addresses and sets the data used to read into the whitelist"
       },
@@ -859,13 +932,13 @@
   },
   "argsData": "0x",
   "transaction": {
-    "nonce": "0xbc",
-    "hash": "0xdab8ea29e3981c65356c58547d6153dfb3ec8768e33bc35427baea7e2f976a55",
+    "nonce": "0xd8",
+    "hash": "0xeecd64b53964d88a7ee032b78061347ed04e6bebcfae4778a3ee3766f2fb0261",
     "origin": "0x66ccec236bbce5f1bbd1b2fc0a4014e57a55ad02"
   },
   "receipt": {
-    "blockHash": "0x28e60a6b9469eacc7a9397f0b537b53a9ca4b3a6ece554aa2f4128ef0b804898",
-    "blockNumber": "0x2765c43",
-    "transactionIndex": "0x4"
+    "blockHash": "0xe98ba7e75174559b9bbfe42934ecfea5947e2b221247a09fa3cef3e44041b73b",
+    "blockNumber": "0x2e59ff0",
+    "transactionIndex": "0x3"
   }
 }
\ No newline at end of file

From 67fb446dd3f4e1ce60356a0447785d1d836c7783 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 3 Nov 2026 10:04:16 +0400
Subject: [PATCH 33/38] chore(generated): refresh the ABIs after the swap
 router setter

SettersGovernor gains setSwapRouter, merged in #33. The orphan SavingsSunset
export goes away.
---
 generated/abis/SettersGovernor.d.ts | 5 +++++
 generated/abis/SettersGovernor.js   | 5 +++++
 generated/abis/index.d.ts           | 1 -
 generated/abis/index.js             | 1 -
 4 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/generated/abis/SettersGovernor.d.ts b/generated/abis/SettersGovernor.d.ts
index 2f0ba6e..b9f2e56 100644
--- a/generated/abis/SettersGovernor.d.ts
+++ b/generated/abis/SettersGovernor.d.ts
@@ -55,6 +55,11 @@ export type Abi_SettersGovernor = [
     "name": "InvalidParams",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "InvalidPayee",
+    "type": "error"
+  },
   {
     "inputs": [],
     "name": "InvalidRate",
diff --git a/generated/abis/SettersGovernor.js b/generated/abis/SettersGovernor.js
index 50359af..6d5ad12 100644
--- a/generated/abis/SettersGovernor.js
+++ b/generated/abis/SettersGovernor.js
@@ -55,6 +55,11 @@ export const Abi_SettersGovernor = /** @type {const} **/ ([
     "name": "InvalidParams",
     "type": "error"
   },
+  {
+    "inputs": [],
+    "name": "InvalidPayee",
+    "type": "error"
+  },
   {
     "inputs": [],
     "name": "InvalidRate",
diff --git a/generated/abis/index.d.ts b/generated/abis/index.d.ts
index 9586460..3d8eb3e 100644
--- a/generated/abis/index.d.ts
+++ b/generated/abis/index.d.ts
@@ -58,7 +58,6 @@ export {Abi_BaseSavings as BaseSavings} from "./BaseSavings.js"
 export {Abi_EIP3009 as EIP3009} from "./EIP3009.js"
 export {Abi_Savings as Savings} from "./Savings.js"
 export {Abi_SavingsEIP3009 as SavingsEIP3009} from "./SavingsEIP3009.js"
-export {Abi_SavingsSunset as SavingsSunset} from "./SavingsSunset.js"
 export {Abi_SavingsNameable as SavingsNameable} from "./SavingsNameable.js"
 export {Abi_AccessManaged as AccessManaged} from "./AccessManaged.js"
 export {Abi_AccessManagedUpgradeable as AccessManagedUpgradeable} from "./AccessManagedUpgradeable.js"
diff --git a/generated/abis/index.js b/generated/abis/index.js
index 9586460..3d8eb3e 100644
--- a/generated/abis/index.js
+++ b/generated/abis/index.js
@@ -58,7 +58,6 @@ export {Abi_BaseSavings as BaseSavings} from "./BaseSavings.js"
 export {Abi_EIP3009 as EIP3009} from "./EIP3009.js"
 export {Abi_Savings as Savings} from "./Savings.js"
 export {Abi_SavingsEIP3009 as SavingsEIP3009} from "./SavingsEIP3009.js"
-export {Abi_SavingsSunset as SavingsSunset} from "./SavingsSunset.js"
 export {Abi_SavingsNameable as SavingsNameable} from "./SavingsNameable.js"
 export {Abi_AccessManaged as AccessManaged} from "./AccessManaged.js"
 export {Abi_AccessManagedUpgradeable as AccessManagedUpgradeable} from "./AccessManagedUpgradeable.js"

From b2d5b054d8650abdb3d5032ecaeed203046b43c4 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 3 Nov 2026 10:04:16 +0400
Subject: [PATCH 34/38] chore(config): record the settings deployed with the
 Bailsec core upgrade

- HyperEVM DAO points to the Safe that holds the governance roles
- RewardHandler swap router left unset (zero address) on every chain
- each GenericRebalancer answers to the team CooperAccessManager of its chain,
  the one already in use on Avalanche and Base
- Avalanche rebalancer keepers and ygamiUSDC exposure
---
 deploy/config/avalanche/config.json | 18 ++++++++++++++++--
 deploy/config/base/config.json      |  4 +++-
 deploy/config/hyperevm/config.json  |  6 ++++--
 deploy/config/mainnet/config.json   |  4 +++-
 4 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/deploy/config/avalanche/config.json b/deploy/config/avalanche/config.json
index 43805cd..6b486d3 100644
--- a/deploy/config/avalanche/config.json
+++ b/deploy/config/avalanche/config.json
@@ -50,7 +50,8 @@
       "redemptionSetup": {
         "xRedeemFee": [0, 600000000, 1000000000],
         "yRedeemFee": [950000000, 950000000, 995000000]
-      }
+      },
+      "swapRouter": "0x0000000000000000000000000000000000000000"
     }
   },
   "savings": {
@@ -61,9 +62,22 @@
   },
   "genericRebalancer": {
     "usdp": {
+      "accessManager": "0x0f5543b12781242E192b4f85240280E168481B5A",
       "swapRouter": "0x88de50b233052e4fb783d4f6db78cc34fea3e9fc",
       "tokenTransferAddress": "0x88de50b233052e4fb783d4f6db78cc34fea3e9fc",
-      "flashloan": "0x9e0DCF7a33bBde6689560C5c807dd2a3dF991277"
+      "flashloan": "0x9e0DCF7a33bBde6689560C5c807dd2a3dF991277",
+      "keepers": ["0xc351c917a7f7b267e86a5f5368be40fd1788c32b", "0x82f603cd2c2166c9d94b3ca78a16a754f0a6657a", "0xdfe85Af4c337d69F658a33Bddd59AbB2e01990E8"],
+      "yieldBearingAssets": [
+        {
+          "yieldBearingAsset": "0x9fD32FD5e32C6B95483d36C5E724C5C5250Ce010",
+          "asset": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+          "targetExposure": 900000000,
+          "minExposure": 200000000,
+          "maxExposure": 950000000,
+          "overrideExposures": 1,
+          "maxSlippage": 1000000
+        }
+      ]
     }
   }
 }
diff --git a/deploy/config/base/config.json b/deploy/config/base/config.json
index dd632e9..6c0c69c 100644
--- a/deploy/config/base/config.json
+++ b/deploy/config/base/config.json
@@ -50,7 +50,8 @@
       "redemptionSetup": {
         "xRedeemFee": [0, 600000000, 1000000000],
         "yRedeemFee": [950000000, 950000000, 995000000]
-      }
+      },
+      "swapRouter": "0x0000000000000000000000000000000000000000"
     }
   },
   "savings": {
@@ -61,6 +62,7 @@
   },
   "genericRebalancer": {
     "usdp": {
+      "accessManager": "0x0f5543b12781242E192b4f85240280E168481B5A",
       "swapRouter": "0x19ceead7105607cd444f5ad10dd51356436095a1",
       "tokenTransferAddress": "0x19ceead7105607cd444f5ad10dd51356436095a1",
       "flashloan": "0x08417cdb7F52a5021bB4eb6E0deAf3f295c3f182"
diff --git a/deploy/config/hyperevm/config.json b/deploy/config/hyperevm/config.json
index 90931c1..ffe9cba 100644
--- a/deploy/config/hyperevm/config.json
+++ b/deploy/config/hyperevm/config.json
@@ -1,7 +1,7 @@
 {
   "accessManager": "0xfD28f108e95f4D41daAE9dbfFf707D677985998E",
   "wallets": {
-    "dao": "0x5C1232b4F5fdb34d487C934ADF5d4e5c01fE34be"
+    "dao": "0xC5201FFE258a95Af986E7cD1fcaD54f3f63f2C95"
   },
   "tokens": {
     "usdp": "0xBE65F0F410A72BeC163dC65d46c83699e957D588"
@@ -53,7 +53,8 @@
       "redemptionSetup": {
         "xRedeemFee": [0, 600000000, 1000000000],
         "yRedeemFee": [950000000, 950000000, 995000000]
-      }
+      },
+      "swapRouter": "0x0000000000000000000000000000000000000000"
     }
   },
   "savings": {
@@ -64,6 +65,7 @@
   },
   "genericRebalancer": {
     "usdp": {
+      "accessManager": "0x028c3e3a0984c441c5205cfd0c39a6cf244ee696",
       "swapRouter": "0x744489ee3d540777a66f2cf297479745e0852f7a",
       "tokenTransferAddress": "0x744489ee3d540777a66f2cf297479745e0852f7a",
       "flashloan": "0x15452454A9735D68df430879B2941316a09295B1"
diff --git a/deploy/config/mainnet/config.json b/deploy/config/mainnet/config.json
index 6d0d0c8..d9a0f24 100644
--- a/deploy/config/mainnet/config.json
+++ b/deploy/config/mainnet/config.json
@@ -90,7 +90,8 @@
       "redemptionSetup": {
         "xRedeemFee": [0, 600000000, 1000000000],
         "yRedeemFee": [950000000, 950000000, 995000000]
-      }
+      },
+      "swapRouter": "0x0000000000000000000000000000000000000000"
     }
   },
   "savings": {
@@ -101,6 +102,7 @@
   },
   "genericRebalancer": {
     "usdp": {
+      "accessManager": "0xa66814ee197d8334274aaeeb4987c534789a8194",
       "swapRouter": "0xcf5540fffcdc3d510b18bfca6d2b9987b0772559",
       "tokenTransferAddress": "0xcf5540fffcdc3d510b18bfca6d2b9987b0772559",
       "flashloan": "0xC9B6279baa19dBB8bCc3250c89cAa093AaBA0bfc"

From ecb7f73e99f1d45652f93e12a01cfba60dee60c0 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 3 Nov 2026 10:04:16 +0400
Subject: [PATCH 35/38] chore(scripts): space out contract verification
 requests

The explorers rate limit the verification API at a few calls per second.
---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 9019a3c..66a0c9c 100644
--- a/package.json
+++ b/package.json
@@ -22,7 +22,7 @@
     "lint:sol": "bun solhint \"{scripts,contracts,tests}/**/*.sol\"",
     "prettier:check": "prettier --check \"**/*.{json,md,yml}\" --ignore-path \".prettierignore\"",
     "prettier:write": "prettier --write \"**/*.{json,md,yml}\" --ignore-path \".prettierignore\"",
-    "verify": "rocketh-verify etherscan"
+    "verify": "rocketh-verify etherscan --min-interval 1500"
   },
   "keywords": [],
   "author": "Parallel Labs, Inc.",

From 1cd15325f8199ac3440743317b8f283fa2975765 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Tue, 3 Nov 2026 10:13:00 +0400
Subject: [PATCH 36/38] style(config): format the Avalanche rebalancer keepers

---
 deploy/config/avalanche/config.json | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/deploy/config/avalanche/config.json b/deploy/config/avalanche/config.json
index 6b486d3..67ce709 100644
--- a/deploy/config/avalanche/config.json
+++ b/deploy/config/avalanche/config.json
@@ -66,7 +66,11 @@
       "swapRouter": "0x88de50b233052e4fb783d4f6db78cc34fea3e9fc",
       "tokenTransferAddress": "0x88de50b233052e4fb783d4f6db78cc34fea3e9fc",
       "flashloan": "0x9e0DCF7a33bBde6689560C5c807dd2a3dF991277",
-      "keepers": ["0xc351c917a7f7b267e86a5f5368be40fd1788c32b", "0x82f603cd2c2166c9d94b3ca78a16a754f0a6657a", "0xdfe85Af4c337d69F658a33Bddd59AbB2e01990E8"],
+      "keepers": [
+        "0xc351c917a7f7b267e86a5f5368be40fd1788c32b",
+        "0x82f603cd2c2166c9d94b3ca78a16a754f0a6657a",
+        "0xdfe85Af4c337d69F658a33Bddd59AbB2e01990E8"
+      ],
       "yieldBearingAssets": [
         {
           "yieldBearingAsset": "0x9fD32FD5e32C6B95483d36C5E724C5C5250Ce010",

From 35f21a47229265c4a2f939f0ef4bc52df23a8288 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Wed, 4 Nov 2026 15:49:12 +0400
Subject: [PATCH 37/38] docs(audits): add Bailsec Core final report for v3.2.1

---
 ...arallel Protocol - Core - Final Report.pdf | Bin 0 -> 1549594 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 docs/audits/v3.2.1/Bailsec - Parallel Protocol - Core - Final Report.pdf

diff --git a/docs/audits/v3.2.1/Bailsec - Parallel Protocol - Core - Final Report.pdf b/docs/audits/v3.2.1/Bailsec - Parallel Protocol - Core - Final Report.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..1f698ea71013299b72212e449797b2a63539e730
GIT binary patch
literal 1549594
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%0D;3KKgnhQr=
zbF&%{0M4@AZJg1%yo;M$VkBy4eXE9A(T7lgp;Y6;wi<OO+i75vo#VMXirH;Js(RlI
zinuU6W3lFEBImGRU=!Y1c(oSwc9!&BCRQ=MKVo-6^l;wGR6Y{Y-+}Gi^lhlBEar~#
zUC!qnBOuSGw=b2&#FH2CcL?+T+1oZUW7{jxDE9#z_97a0=~V+=<3eO^*JkExkvo^1
zgYq%ccgr}=DV!p_+CXO91jn(QOaLusZ^CJV)yUFx!IoNmH@Ml>L4fv!`#Kj5Kklg0
zvQykp?(mb0Fq|Y0Z&BV5Nm{J22r*SBejPc7Czdd<_F2yC-1nv9`B%Wb<Vi`ajQ1)o
z>Aa(6sAVj2Zs{}vT=+FNiK=^8OHk2^rc`#0<~-prx1C9y-DSCl&4$c!Jlx$H#S~o1
zlC^Z^b(ZIC8oC#UY>iainu9K$ymxBVhwaLM3d+gtg~I>|q7$*|wn<((SC*NlHhW@P
zCYz6kw~LHIJaoCkgM;ll0yp4YO&wVc)A5%H-s0K$?*Ow;)7|e<G|dqx5$G(z6c13K
zYWv)hhkC60i;<jJ$}Y=iP13QUs5heRelxUywn6h5!3u?mTn39Do=}R830}2VyEs*>
z6rXZH#c=Vk?~26zx=y%oU6YxLP06?zHTdj`{-jDT?+3PZvm<+^dZv;~(}ds<g$(b8
za#6Ot<Y+CGC;T;kJT?jQZZzlW6*pd%!ZaeC3TcU})tbm~G%QsMo5W(B;)MZgl4hQY
zdBqct3TZ)X@~LF&as?IW9vl0D)dYc1VIw9M!nR^SSszCGyMPN%*+T6JMc_M%(wtqg
z*?FprqfQUWTI@R?>pJq|WWfM#mND3&6&F6dTs|*vv4RyG^gtZ2)2ac4Ffih5S1>Eo
z-+hnJ+#Zj&|Hdb#oh_BMN!Bl}Pj|MyOqy{sx(VY1kxant2|`qTE~X(-5mS2s$RkgP
z$N2#(p7J!M!i4fXe4n#5gIAj8Z{+M=)nQf1m2IQzhu+P=L3Kz-=<-c!#;k`_5!_l2
zM_s_$?z3IFLy`<|B8<0b3)Id8-|}WTUCN!@M!>Z}bTOeb)FaWy4hGbUG0_@&89CWY
z2f7r~2I{_JuD1N+51q|OJM#zFi3y!Lhd(P0z@Qqs0mM}U^$diAjd^Zg@{HeuNs%l*
z3mBrst0(3MN`lVU=7mZtf68mu!w;|K%K;e3lu$5nQt%s?H|1t>6TXYw79j%^PRmgf
z4)#KiL#53=C9>e^r%q92k>_pY%etd1Lh;#hKOr{z_Cjy*e-JKNk5h4Mdg?yhKR?-`
z;0I1tQ{`HFzazj=qQ(g3eA0e+dGGo~k!(HNzIwlelDuVao|Dziwh{iBdHmItWrwL9
z*^S4)!I*maki!Up_lv~-(IZJ~PWfNrxc}oo6*~h9)BlL$YDroh{!5Y~15Z{{p+%C^
zArM%&;Q}-24?}a*h7dtQl8~z6{Fb07UYzCR*g3nNrs9pofK)e_&DN}SD|$XILXdy8
zn*ER^eJnoTgOhr?QEum@lYYOM94PtstDbM>PvD~5Zg<yrb#~9^E&BJCSPsItEWgj=
z!}a8EIw`^LGLOkF!baH8Scd;|&b}Did0#D^@(lR_{2!Xs$!7pPS9izv33=k_d=p*!
zKLb^$fk#F#i{#%w*v@3`QH&qwi@h?p0DZn}J|D5E@VN^`uCdRCBwWAB(DQ!rkJH~&
z4s*_rA)pn<I9-eZuDdxYJwz5H`wXXmeaylF!`$#P3bm=FPM$)4D@b5u=F-D%#qQs`
z+hV7io!`IX+Z{OupO<y?+g_R~;(L(b<H6XZ6I@sXV9(0la(smS2O+LA{C}6T{5@W;
zFORkVKKT89eiqsPeXgEwkHX{gBlV%@%H;a6oe%E%!W5GeV@d%CJDP$2KKY^Pff~UK
zEDV1EpkH|2jHcHAjP5q%!<u{&{O<nox-&WVWX>NMq08&$;qnoF*Y{uSYBD8%z+x4t
z@ym&m209rQAi%&=_0!ku;|M6Sygx^k9qrEppePW^I=$F)H8BPx;C6R+MNI#Qh){j{
zYJo>*)%_H}FA_qU_DkyOvM-Dr$A$a?qaUz6-U5L7jU2=AAR8yKFdcQqgW)0qriYMW
zI;N;}%nl=$`7Y1ppYPCyVSs(ryXvAyfk6I*y6oO~6B!UNd$F-|g~0b*idkY0Bb-1_
zOLaMq29>*7VIc+TeukWo)r9_6DJXV-uFqJ+aTwSbHkp~t*ie8@gH}UdClOBoC@wKY
z@l(>hfDk5bTaQ0jEq03uz&JR#9%~3Q&c;lPPfj2<F^Ew}nmc=}8jD)eRM)oo^}vV@
zjdA9TAqvYhdB3hoZ=q%zq^Xp$dkbY&rDQsQ-Iq%q-<!a)A|p&w*#F%z`uOKT!(+66
zCms}Bky!?Yqv#)9T#Fhq^&`D)$>+{$h1K;2AfOZC5}Xn0@aH{K3&9xI+MS(9-R~=b
z{T!K194T8)1C)fIWQM2@pEzXFFK$+5+e&Ds$l{}kAEy14uOLP(QAUd*rR@UtT{cND
zM=?`h4W6bKPyKbT7Qnj2*8t_wZVWp#am!JZX@a4=vNTni{hd>rzu^pLu`|o1sE~{`
zk#`>P0*rihYhe;+L4xA?G)uvN=tuaS8lz)+G1`j9+;*Rxk;Ja9kM|cU+dbE1R00M2
zd_`u`FLzzX9(5$s6rAyo-iT!3A0%H6b^N^;bOvF}0{|!A60K>h5Mi_w4V*-cD>2$^
zO#3Iq0P5PM!^0fa_n*=5dao66Y}7(~Ue!Nn2LBz_??P2u!By#Q!yc&U2A1z%0PQvp
zB)qjAqU#nv^o)OO89CG-fQ)$Y<Lh2Cx0|OCyorZ_z~>qdO#qd1CG%VpHtnmn&})OP
z6;H;gVbMWRimgCpI0(w~2D!X2Vjsa((OSS$v1#=Jku30~g(>g+)@PI<AN5aqW~O&%
z1pxrs!Y@84WyTf;;vYE29f5+}3BhT7<@i&IPXCNtaGVe2R$KuD=Ot?l1m3_@0Fs3v
zq`Fcj2D#=yS{KKlN*i*=L;CxpyjMo84`Edg%xD|z3!ryrB4V^Ce=d7p$Y_rG??W6b
z1=P%_)Dm?$el)PE>{XCipT;19IFlL1q4zdIv`E18mefG=874*U2T&0u<hBd&5M`}{
zPV=NTcH5`EAqn3wO(jco0xJf1%HHEhX#=})c<wk&q8nIsogYwkBlagsWh4G&s??48
za})C<$4(b+eiU0Im<Xos(`0*sjp8s{bS?S0_P$QG_XY*<O0qadsr?xKXuQtx7aWB1
zBceaGhf%dJk}o0}@iDDvL(6LghY;~Vqg)01$O(`NFSfIgEy36+UZ_q<fFyOVuBiMz
zQ2n}>uBwOEyGoP#*NVRCpW5Xc?GynW%D?eqQB5W=b~1B&(OC{)j|U_>sQNvhuPgfP
z!r;g4Tb*3r@cjZPSP!4Ifo1%l{*E_~<P<;8^{P)JmGYd7ZeZD%!`cwy3Kj5epi*|5
z@Y!C$%B%^78qh?_N8T6i$ef@v>x?=5R~{}ap{9a5xxKF)U^h{6(LfhiM=)`!rSpKA
zxVp_>{n4mG*vlLC1-79Tof-6Y*6Wpw)D8mdh;@I@L@sD1@Kuq14;2*hD@k2+GqOV|
z@shQtJr({DlOE}<z|Zl5IGQqw@Offa8Zv4cGT(x}oP(ds4k18T3F_dhq#QdkMKB=A
zsPR5B=QNRdfRii`fGLbX7-E1<Ii-N1LJIw8{1{=kG?LXBxkhj{TnAkjMEN9UG~?;X
zqWd6--tefpe*!P}be%(pwKuth#YLrT!+!4eIs6b{fq+NQh^_VY<V4yxFzW3wtF>{}
zm)g9K`qfJ#nF%O{FFHBTiEd4(DI-xlXOuhYsABie3bBInUbYS?KmLw|AQ90vB$yQD
z*^^sU2|UXLV%!JW=L(dMY;)6xwU4bMiJ!%SX+#TzV}(b!7}att2?Q-1vYtwogRj^p
zGuJ@E2r}c-@X2TB0q-fXMDwDG!eyPL!V>#snW!5A<Jn@=+>%<Ww-K3H8G*pkjn6-Y
z_T?X!u@5z94H9NOxGCIu@-~=XrT?xIN7ZmQ7NKP$X1X||Cflw<&}2lj4`dK5p?*eh
zfunbZTr_H2MjjPH!Z?m#n+MWnw6ecq4Xs?gW8Xy!I^wU9N&bOyCQ~?UHhsuYISbuW
z5<pg=bLl7l=LV1~*$!^<tTP3E<x0*E%bPC<31P+r7pUY3&uA9$&F@(ugr5ty#Q9_l
z3pSHq3jQHp$rp}iq@>x8Ew&ug&NJhRvsdMy+F-P_=jdY}8-n@9SFDCj>=EQdVcn;s
zpeCn9tNisoZEN>eUWY!Vum8}#GC2t=1Ny*X^*aFxz40wySl?Pz#BbXm2epy$FmsD|
z8oLgDb!cb+3~jZW(>Fo_2Al&}dcDMD7Br7-p?9<B6v>bZcb^T})r&;xeMRNp=*IwJ
zlpD%5K!Tza0mo=hXgz%4&#%LL5}D@Q+ovxN{f^imeG<W%0KnMb!d}?$I=_Pz%bwYg
zjpk3?!eE*V6+I^#b)}Cp^i$=&W0|5^o=CJ^Sv7nE^GakfqC#T~<6r^K@q>V}hUuIa
zdlmk5>b>$f3tkv~%~VSZ>`_1pGUkCn3Skh8*f`gYlxK^CS(5%#HC=f&WU0hb9-w<S
zki9Hb5~6trTzr>0C&U5<(~v%Pox~xu!v^^5A6B=YZ{6waW5^g7r!lT;I)h55aoq0J
z3g^$ho0qI6gJ9aGOY#*<>E+{U%)$-){h$$p21}EmsC3<DJmt|AN=p71kTCi`_L8*W
z8o_N_{C1#WZ13ex7uoDM-cJG9Dd(=25gE0a`#jz2aMj_q5Oj(xe3ET?@%iZJFJ?~P
z1%n(y?1}ao82}ZZ$wb(E$A4iVjPPoHsQ%2eyVC~ghpP9%>ORId?d<~p5sBUO2@ful
zC0C!u#iSx?f!k+29^f<WwBqZfijV}=GG^d8X9BqdI|^|ZVz_;f2SwF&6e-U*tu7-J
za1BdnSCJNK8^1e1^HYYd>3vSvmbL^o(p;TF!g?tLR7@pIfJ^}{?PL|;Ii_?5ozf_P
zuk7gfFvZe9<<Nqxba4<e{BfjQH&Ly@PEImWcSu)ri^)~1{)t{(TOuVsL3wi;4-2nV
za<%m+gU5P7{)U)aNHe8wsb;ZZ23(a}L(vGov92nJy7;{Ws@9*?dM~*%A!Y$V(XKPs
z3=m?43vm)v(1b;>o^V0tc<#sQs(O0R3bInzuqAhTesr@RWW)1TIeWV+`xZ8hrkjXz
zI6;|aU^Xhd_$Bz=V=NhFs(NWvIuB5C^=0mXG`ze}Z=ep2s7Hx%AVhJ<tOgpeo(byR
zq0ZAJs7amMGG1>Wpe1Tge&GI7z3{`8Lciy6tsn+)PpVKM2GGzrs+uicj_K1^Uv2vX
z19Oyx=Cos(<(e%nC+15LXoEX|?W##xeJ1cULW$p#u8T-Lhn{LT)TbZoDk~OUHD`(W
z*R<L6vW-Pcw2HIZqxB#CYOqeLg*+s@pHR_8oTYS-mq3r!Iv|E4lB~8?wXQscC#wLR
zo0ipKKUJkqlJO8FvXnsiXjYG3K{%@V@Nrr=YBu5%2ELWyGgnn4|1Dcx2(p2v+BSFe
z*75<(VCk`<C#w`{3g){eZ)}Wv;5|$~w2)*)4pp-ewGoMqT>IF~&vvacF27wVyqOjs
zL5ZzNsFLrOJk~5zkj(l0I$;DU5Ei5lEXXrZvY|XG-nyl`JD-AyS4uU@&?!u+bD+#9
z_&yDal@FoK8^QYuw3#H+)dbwuSPx9L4|#Hvd@QLstyN!TkF5z`RimV4ZbZBN4uYu>
z9iHBxy%dKR>#3}NW1e(aZ5}~s@s1+}h55C=Y18|g08unkT_30YI<kpC94*vhX5}IV
z^;iOm7u{7sb_L-f3HPO;;T&vP-DW4Zd}ya)oX}EEh5jPXh>^0BauB|BVK4ofel>~=
zgD@7F%YdAv{2zFysRgSfUMuA_yruABJsh!!s#Q*CHhhfiwW~(((#)9T2MU!Dd|X7H
zAhav`S(Txo-(LI*mTmFZFo*$nl37F4e!n~9y3;pD?BZcYu}XRCsDYkMEr^i>&n1GP
zcZ!y^mKGFjI-U&Ei6kJ)Ler+GX+7`Dvex(t`+1npvbM~5xDT&JD{Ug{Vtl>!<Ts|o
zaK|(XohT_9pv$2zqq`BP?7V$g2ubG0VlOT6{)QP~nP`Jjnel`29sz0~DcAeXrsW!y
z#~w{CI~))rR&2|GA+5gv>w95eV0aI<u3F~~E=`6G<ROuW5(w$GW@$o`j*f|B>TA&H
z0O<h1EyvA^9xqdG*@yybX=82-X1#9b^N!5FS}^D$#q{?L?B#&J*T->K2DxUSWM&L}
zA9;NwYCk8|Pz0jljogh}@rzfE6nT!48?jpS5%eQm$&vW4A=T(c!dmGJv}O@~e`IRZ
z=jvQ$o`V4PzhzI|f;_yDDoaFUMX>{E2v8<?`|wi%)JwECb(Iyt&3OJye=hZLu6piO
zAwbZ{&`C+R{GK6L+V6&(H%8A37De=%+1n$9$$2ox2tCFe1?Otjt-MXP%18z`ooI*3
zB6~|q)&GG#qcfa`B)jB_w<aOyTK>(J$h)J|U2+NPj2*q@kI8CDlYGb_!lW?yGz%@O
zrx{hdl|!WbbMg_c1l1S1dPJ>R4{kIU4QWQC8Rl%%aFb`-CI6VZR1R30=2y1e$0e-1
z>c$3H&?Z<LOTuBv`5GUxe^prTTQn_>iTNTm&wX7dTBvhb6ze%gkj3DLQ)HXMxpVe+
z$jb~($SBK_jHKr#P=XiuhTVXF`xBFKIBu7kRvk*SO1ME6_YC-N)iE1L<>b4&A5<-c
zEVTAUIym0-wkP*UwyoyzUWW#;#04+Z15C7Enkh@al50k{-4t81&ZC=dy9bR}#1^6`
z%B}&80z_?e0+@Tr35maMquJNP?Jj)3W!bwCn}SG$=o=Ay{P5?D&*>v3mJeSkn!IUd
znE_zuWj#*LaX&|q_4oB3gA_E^?kB<KplbtDCz}^Zzpj;fb>wj;?_&Y$KKI(oO$`gD
zlCrYrFKElylD<A*lO;XiAiNUlDn^?>%cHSIpwkbN>Ek9jt!XgwFIZ|;RnMx4TxEPu
zl<)r#Cvq520n0w9TQO<bH*^`dsLj1jmBgmvrGcBxX`l|3m|!cWj;W4E%jp*`q%0Wm
z;+1}!6g39#*%4U?)J>-Dm_~xy8lQdeFn-5P5AsQ2cMI}s04^~K_O;&kPJbk&qO}4y
zWJVQeSG$-*C)8#<8Np@WfUU%y3p!7%RW74UyR*kt>lB{*wp*}bYgdR>iK%Cjy`+z&
z8g$rgh38s&^x`Y5jksl5o6AIIn@N&F0L&VaX+UM(Qpk&rEsx$G7ag1F$(og8x-z{j
zDUEqG$+b>x-~|~wD)<SmwJ&+_ea>oph7MT9Ur`ij6%xIj;%k~4R7PJZQH^M6`IF?$
zDo^_bm$Xx~<#w@)%GBp4j%cuNwc{We&FzpuA>*^NeLqf)<$BY7w*)0sh0m*cz01kD
zfLiAf>wztFv282~2to!M#JbV_36&fqf%U_f4U>2Qxn{Cdjt8t)5Su@X-rg#k)_9LS
z{e>Gl;fB2n6(*I^p9VP*c_}i*w2fJ<kOcr%?*f83uTfns%;LrYz$?=BAIF8rJvD1e
zBma^?h1_OWuWLJ0_4w}$iWKIvzd3MfUknm>0qOGQf6eFVsjCl<mJgvzklH<l(|?01
zQ6s!~OUk?5484m>%1VduCjO#Ug22a{3s3A~b}~c{h5@)%UcF$2MMohy`bh<e)u!5N
z^DJSe5=R)_FAeN@<ca6);b_IE=5#D_VDYlWd*=QursqSO6A>?(@I@OJHF#RYnhRgb
z3V7A#=M<@sx>Mc0!OD4RW$iuHL8k?`a^R^!f2ll{)i@|-7`P+RImXIDwCwNcaFTu*
z``D3|Li@XldJQ*kWS^&rJzG6&*I`R9$u2|#3m>9=G^}!tfR!Y~se8R9r<!4IntYHd
z5GU_sUU0!E*n`_w5pU2pKTt#2TE`fX_1w70iy~{iXIY$K9xIONlLvmBbaov0*(g*I
zx5(br%dR~;QLy&dUS9Lh<C)E=!ne(tPHdC}fj@NfGW}rF(bgtwua>R6N%Y|%P#&!G
zpRTOc(m;$Z(>IoO!M4tnldDRn1;bWz;nx|FJZ5xPFx=p<psN4EYZBYf^RSu$*RPGA
zz%AH{P^weRHOQEA0i40sMOzu0=q%Y8l`)R7q&-g)Cj}Sj&=3o;D!A(dFUIQ>YBoB)
zAjgVxOjv~3Hh>X}G9)1N{LG&NtRcL&ia1kx9RVdY2@|@xs4wgqw=$>PB%O4Hw;W7|
z>r=dRA?FYd$42Y^?q;Sz8za+<P>=U|QSN+X7@(fgMexp@sS#>(=%Of4y2Cbd;xu-e
z@io*dR=&3M`VDs9+{_FIs)`)+={SY^>8;B|E`^DrxLMa&yA7PVPrSs>>D}l~G^&!O
zuybYLWEE~-XSi5<w0x%r+XNi=qu&gf^48vC=9g_J5u<EKT@^u%e#yt)=?k5e1Z&PW
zbuW5WG;d&^^R+QwYYAz-;4I3!R;@gEO?(M5D=gfyS=!W%_77RN_q=G@83ToSBaRVe
z>&P&#KjIA^I(InJ#D&K<6x(H1o<^i>&1iOIM~CFfv)<eRu6s~O5UHrBJ%i;SLu;Md
z|6$sq<H=_v9>~Yo<3NGxhC^(w)ou|{v#UNISv*z8)_>Ptu)nM_@H83@Tdl||yh+|)
zD64h>z*{S^y;l^To(7Ln=3VV>HnD>qMc5Ni*6l9wu}W~hzVRs&4T(2Esg%)m1uy1p
zla3-4pALC7tL`nk-vtwBtfFmb0(jahNPyMUmUp@Jl~GHL7e+U#GTJ!_XrrV0Q&n$P
z*obB&9}tprZT8(nb&jIAZVY>clkFm{lGwaA<r^gRrXoFqqm`g8BVW`R*e@WgOo>y5
z@mpEAsOpe$wS7{xfy&>0L7!jo=+<YBGeqR?iB*N>5*vpRuu?-eS+sD<x7ryEl)SB7
z@I?cy1OD}xc5$^aY!JkRv9fp2NGm_u!U?nzt|&%r44=got!YPPTnjK{tRTDf4N@QW
zVUsHa(!3C7*<>9vn0Qj_;$-7kgxG+%ZM7_mE1SW0T5rBo^SAaM7_3)xjRS;UHhMiM
zZ3qW=evt?d_ZCW(ja$uAWqYE7wLYa=)7Tuc?eJ1&e;ripZqeNXCzomsM})P&sEKWz
z9Sl5;oI^Iry0^V*xB(e8^3_vr%;S@<SI7#F$0oIQVehYMk8(8ZXbo_5(J`9yx-5XS
zFJ3O}ywL7PDEIl<Z-^J*{eUpM{9)M-Y@xX(2M7wZdUvK~Py5sD?#{?cB}?3`-3d|F
z<2T&E4Mwsv8A-RD;FuYI(=u3HT-_XrTp~GL7>OGIBmj%J7Ar4MzWl`Lv<kIpE30+8
zWwW-iXi2fj*~Q@YH}m|gjLgS2h+M&4)obk!)dmmOX_#nYSd3bAw~nz3`eyp$iz~6N
z7v#`Ax|!%TNnSab3Gd@siWSy8iVzOJVaAS;QN^+MT8%H_;!xK{T3|tEG9}-af)A3G
zUHzfC_8dj}JgMsp796E$!KdieYO(D!&XHENmK~~lplKd~$&iQD14x;@i)No=FM!DY
z<`{TnM@pd@otv{`QGAl8q3-R5<q*1NEoln48SEl9K8#0Y{15!SoM{EHOPe+puCRU_
zChF9!>8^LGdSi`z|CetN+fCy!E56wmt3s}f$w})HIk2wH<Knu4`65Y`Y6kvRva)D)
z;7DXE{-j{>Zi8I1fA+<tFf8U0&-gxQ_|Djtw`VV2VYGupA*sUBAQJ~A?4ZKOHOGK^
z??ks#9>3DH@vYoLQTD@9Hd6<UZc|xYhtdmi631}E#>J?#8E`NS*=$V|y+5hsFbEU$
z9SwD$624@0HxrkcS@T{l8p2xcF;-F89oqNi7D}I!Yo<ovDQUV&pj65A>zdVOSz*)<
zD$zFs1p|ltg+7O`p8B_|MTywo`EA{<>pm706zYYKVIytoH|<vIE<p(c$wGJ8IsewQ
zc#!OVQ{d$BS=X?IAhhtD5k0**tiL!}Hc!rMAp6}txk|!5n3TIcU36Gs@QG^2*u?Wk
z1<bZcjC+0HG$bY#Z9gB$nr%PjEPth-%3^<Y2>r4oWy}OtSt-kuDIkJ>Y#-(;^N|#N
z<HJ`r#_Lwd*)(BPq0w*sT&sA^qGkRincBg|hlO=c;iV!IARLN5(dB>k$ElCNMrrws
z90jiWVoieIOis>+%^0l}?GKqyJo&F$^QlWgc#y}lcRVNLV8I;95C$C6#B*hDr|eV6
zUQq2tw={SC<WG8hCK`qt$1Be%Wg8o_xKdQxZCVgi2j4J}3&99YkWy!9)O9}2F?@Hr
zKs3+)66A_J6K@W>J9V>2!&t(b(b0lB^vM-)deOTlzhVS{Or*b2uGMWn`Or?EiI1s8
z356KzAl2gu3%szS3_Abj&bNL@WJ1+XAHnF6>wTHb1NoFn@NIqR`Y~TH2A{qs@%83F
z3w!_LM##k9{plHc4|IRLT+QA2dBM(+-`^?n@!Nm+mkO`F#}d@*?f(6Fj2@Jdf1=m+
z<MST84YAsLNl!9=9-Y}#wvF<Y^yA12BsiNQ`cbkw&;Rw!GxZ;vf#<(mi^(7ORApt6
z|K*bRf1LhfVPyFqHUpd3tucq6p56d_WMHagDK!^#0*E;Y%}oI~acjUAwZj8$lDh1-
z1AzB;!Fc9BGjY7uFIOYzT3q_Y*f%VZ%PPyyA8}wf_U?ax;YjcAw()a+zCbia<!1f-
zUPsBX4tn*zy}u$u@crC9Kb<gr-)c+Sa(H2dX$E6^{XTxqe=Ytzz7;ijf#ei9$`o`z
zCuW1Wwkzn^B*VA|z){@N|I%*%Yc!bkAi)0RqlL{J!yOQS53Y1W=<mPTi{zQwz3_Uz
zF7MzFkH7DZcXRptFvC0AZP*yp2rW9i0I~mRBmM=}{~{cvDPK#E0g}`RVjo*0FgBg%
z725fEy!#aw*zx~7Ecy?AzV3Q|aLk_oBa44Yus7|8<B$;?#=rQ~AfQqhLtfLd=JtNS
zJ-wix3nA$wIyY)?_||oc9S@4b63VlYMD60$#_hWg3n&S(v}@;`Q$q@4D$wVCJ_Q3A
zhbeo%LVvwKadHwb9K*fw`1A|55uo;X1DD!yq%kDi`U2)Irmw$hB%)45r`<%{f3rdX
zl?Yj5TaA?>|CRpr&K-w4a_Wd%j#>CB-#-RViD%HoK6xAn0-gqBo%oEO!ZOQ-LDww5
z<r;sYEqf&%v#G{WVPKl^S)z#}Hdrd`s`>kU9E$+Dmjh5+4Id)^DmW)YkBPs3?~Sje
z{~tc5|M%U=@BRM$@5{vf_3QmT9kJJgzsrw*h<ArCbpsYAfuSIoJNEl}6#8F9kfSC&
z!!1-wz>r6G>`+)$%g$(~UDmTnD%_vFDf9C?wv4}JWRHJbr8}<Id@Q>FI+GjZrmRmE
zb>cIwKO>S76A*-20-{_y6;xVs(MUrTp~yDbMVm?03AhU<LU6LD{`wmUWeuMRyJ1c<
zreEu|VbD)SNqbW3f%3qi?q>j&$LAsr^pRhm3dr_liL=un>>Ec9o>X=&_K+>-JjF!F
zkjDa}3wNZ+n_4CUI*zTY$4qb~0!D`8#JgN4KYtd915ISWmuGjwQBDXHZS^JV-36z3
zAD(Y_xZn359YUf^-T3m|lrnR*1Pr^V`Zt=!`E$3Ub@KM$YA-nzJcCYOXfzpAC*Gpz
z26sR%!{1FXqXMJMj<3$Trp^X{j8XX-Pfk`^x68W=c?Kcek`B@Hr4v33JTBOHHFyE!
zPP>CC|FN={vXX*`5w__dF=HH_w=pR30rquZ8XOf~UJedn*8h+R9>1*hOl>BoO04ZM
zS=UNe#32$@*i}C`&=cDlG@iCyIf^g5eY_a>i*vw4{Y1`3t4tB_x8dd8&Vp;(@RdaY
z%Fmzo_0jt2d>drZA=l8&W>PSBi~stDKHh@F&MF*P&n=Y#LXrmlO-C7tglT=x$z|0l
zLJ>VQ!_FbX<b<M#TZm)y1c<Z1FTGIOZc||eL_-?CPP+<}W<LdfEK!FP$4EzaEiRZK
zg8SIUlul?nv5}5oX6zU+XPXSW0xcagg4C<89km65t|jVYpdGe++$0nDtiwiUsOueN
zjdW2FhwnX}ycua~L(|YeZ+N@j@v6ecJgJ=UVnX>=@$fKX{S%)eUx4B<#Zdb#TV%VG
zz*~_Eo8Fj0ouT+WK=(m%KfhVrjyBDU!&Hha-uDqa=GYiheeGO?t#f`<QZ`Q&j}t4=
zs%T>C0#X%RMYJ6E1=^*HkDSSts?PJpMoT7=A<s3xXLY&Q(lwb+ddXBCrIlv$bu4n~
zgtT7zBIk53XpzJmW*C-LtuSSS&74txdz^DeuOD$N%=LS~gzrmo84bvtkAf{B;@{nO
z@An~Rb{n4;zcdnV|9H`ws&O_@Y-6s@ixP_3Ly&Gub^f&LznGfkBK=tK%1~q5$MGpd
z7@ZpvWw(^R{b&qzS#`zQ!fiy<tKz7Q!Qc!h9haRNW8-u$%R>(d`Ji#{>9&<Osu+es
z>r2!a=7x)i6*_HbHe_C;BDN576+_K**$V-~fvss5CO~P5uAMgSpT5Xn)cd-P;r*oO
zP;`Ysp^mKBc80;ip6p?~)(py(x9nxglQrRzKX_ovcvhtK8g|xqq*<I~t3xc!pjf9h
z-z7Adxk!=8<+ct&1SHjsjiXx|r4*D!3xuqj1p5zF+9RM%_4{XZi1lwXKva?D`}h0p
za{5Xl(TV4#n3vGCOH#z5c-(N}+r6W*KgCCnZEc{XL%|7@`jg1{zGl0RO<gqkA{jQZ
zPf}<IRIe{Z?+^jX0bMiQCv<1GwUgoIg*Krg`?FM%K!{w3aa|fyvtSeH#gD^ewZuu9
z`0PY8kri%k6MV6u>4tsUP-Y<6WA}P0KZ9Vh-mNHAd0nEfJ9l+8f)=kYocf~#9?G6U
zXrdsMJ@et<cOkp(!%e@1D{#fkph_Z1&DO*;$D^oew7X184DW`ky%{!qxXQQt7;dvX
zzJkNw<cWxKnuZ!9sZ0({3D+=X-J*M7$FsKK_DQ>ewW!&V0Sqo0mUKA+rE&o0^$EMY
zq9vG>nj!tLA4i3ZBCGJ{`dC_ZOq)%$4EqZGih=85dG(-Vg{Ho!p3Qt=nnA+I!d^<I
za>w4t#nR)YxhR{;Vegvor!0<?2;qRj#rc6IUUbxYz1~{J;cmcxyg^a%y=%0TAJ6MK
zgg>}Ykj|2}J1bh7lYBKgu$9t~=c1z+Av2`#RWN;V3^-1Bxh;{IiqMI31IL!rX_;N!
zxL1C|Qb)OPqI{{A(h_F9z|nQJtxNmoPvjs=@4QR{G|F_-%8lo^;p{FKLgBK_<*;7V
zp%q=89{H4Wj+%M6ye&}a3IwScL%c8E;T@SAqe}sAu6?b4(~A&YzVi|r<zu`wg@~UW
zXVngh0XJf8Zl%h_$VgcIkXxgW)STz#Wix48%5K?`sVjW^HiJJR1?kGxG}ZwMG7Zl4
z&$MFWD%qp{^COpGB|~lfOFOE@Qb5WH(boM+g_w(faDSb!o$aY;qdG@phw5L+GHvuz
z>Y2lV?G0#GR|^^l(q!<Vbg6(UBXgh6G+4}?%Z#y}Tc@!Xmv%OyL-D|8C*dLhhj4_W
z6k@*OT=H043x|;9537q(U2dtE*37GGZ7J|nrjv!~A@e=Sd>~#$mnK^VympHA{smsF
zs&asHb<H!AsF>}GV+6Ad?-&z#&1?6{VK*<FO*hUFLAu*ijAD?K(UZ&07uWL^)vlLs
z-5gIZ>UP==!OClm*CsWcQ^LQOqCYI5f8Zwz2>-k#E=@ZQ=2=e4co*A`3H!?zdKISr
z)~nCD^7-IVdL;#iL?};P-74P`QeY-s(ffR7`2Q?)?Hjj%v+`9mHspkN+f$$xt;gZr
zuAbjL<C{bDV>lV}Yl5}_VNqXXApbwcz9C4Ipxv@<+qP}nw{6?F?e5#QZQHhO+qP{@
z|8HjVW@hm=`9)<!Wz;4sGtPJLVwTT?n-!M7638v#w-g)yz}Og2V-HR)`3dEE`-5{$
zKq*8eyU-5Z2>kv#vEa`wVd^W&i(6lLPvuxshM=y%YkIVBF}si1YMd|J==7(+M^yJU
zyz_QNSXbVVVu%SJ>3OA(Tb{1!WZXabldF*=U{o64-!FFs5L7+_Z%8KO7IIWCB$;AA
ze=Scq;7-MyQDoQHEtFoSMi?43w*VaD;bNA_fAfrR5h3~a1Yr`bn`>ebTZXMAG_w+i
zR2;{HAcx&40}9E!7md^>%U;hDb3qghWy-A}<%6I!6a^F=g9{tDcxA>!lz~fkTkc_2
zk88j%dgT7K+S{PqVOJLA9)FKfQ=iK>7LS9x9u6S@Avus$4(O3QjGOFLKlGMpY8V`S
zk#OnaxR#(Kc8=-IcO#I#JNC6CzJ?$k1}he?WwOs)+tkj7q%j)n;-;JhpJQ?hGN}L1
zKQ^d%1cZQ`#%ZRa8soR9jZFQk><xiNGK|B@GoAyYE;dg=wgWn_sbeT26V=w6{#V75
zVq*{Cyg+Cv->tw45&bqEZ_oDxAYfAnXRYi=+xf|dS$9+rMoP(5n>NLzzrh@<W}qJQ
zXioQ!=`BUHb?R3*@FK^GJ!nu|J2@5i-2@7At%XdR^MP_;6~jnJINt2)9E9gU##Yms
zVLt-CK%b%@L5dBzS@og`{kmdF4P06it3o-Xae;aDl{dkJJ{sdFG|(>rtYZ7g|H|2M
zLH0GCILHzDGEeyVxEZOlk$ri#N7{4i??-_-RDbso2^)Vq*RA?m=Y^RqoYFP>JrlzP
zvF$D7@SxNfwwnSVYT}BU0_FKn#BoPCw;n7de9FKJm-b6G^9;jz%ghGU7d3(x)f}5w
zgAn+=UBS6K6nggbz$dP<C#Hg$lxEFrxLzpcZ|2DjnSW@08aIj2P{%rk32Cu4AfsEE
z`{c^Sve!Q_M9NqwqN}Ag@<=RYn@ahc3hwG@?$g8$5i-~!=-#{S5g9m9*_C^}ou&k?
z8}K;DO-}z&-F=|oS=ov7R;tMHPVkiyBW7tGAlRB;;nqp-R9M>32I{)}+4~1v4BSQ+
z9D$BdcHDvs?t4-|8%Uwj3#hV))vMZH5J)YuF3wNv6Q_w`wC}7x0_UlZJO`;xwQQKe
zanP%yNgBLd-pc{y8WEP&!R2UO`!-X77Q-QSv~J>692Fw}7RRKb!V&?jwQ22xD2Y8d
zD2pvN3sadci)b;8F-u@F{>-oihM5rCKJ`1CCTjbQSVsqj62D%bq{aby@D+^efZ`<m
zGLJ`}dPz=_bQ(JAxoAu2NO9V|!3Jq)Eejv1vtJ`zV^Z9XCNQVU0}h!HVB52?{r)hv
z?i|xqaQsmz$&IG|=BXR-qdo38fzHVpfmXN*558=R|93L}pm9Ni3S(w-^BkpQAq`p$
z4imy0zLZ;t=Bdp|#zOskK)}QW6fS+}Wm}Ysx#<Ifg5NcjK^lFqj8A*a7G*f%z0?cs
zlkb==WhAlKMOn!uCepZ_@U_}LT^quPwQhK%!ceQ%h2=;wyakis=9wS)Fwp{2A;`Yi
zWl|BftJ7CF2Q$1Kw{nH?P{Fxa#lco2qW7;?^_gi6Q=OJcXG(DmqlA2tIMl2M7kV_!
zZDAvL9LIGIexPK<s2&|0PCD+8ri`bzoJSRn9)pSYW7VaaE`ealVQNURQD(3i49wcd
z!QM+3mr@aRy!GzWXG%z%|6VriK#AeSvCvq5rm-(h%sdh-ru7*q0IT|IAl)#%cVU{7
zr;C+Syd;kM;p}RRaVal#BCCabMsMu`;$JB;<7q^Pd*?_Q3g#*Wg+8F@-z2D@Fkk1<
z?12qBBX$lqfN=q$7C;EjQys5nZ{P+QBOk>AT>=7#sp-z521*tu^c-4zxeZlcS;fcY
z>V2eXQsOD1V*EeDL%_5W$I#xo;Y{<|XM7=inDyx;LAP@#|4<~Hjv8{5NMSg)Q(H#c
zmBZ4nP$cdRz7a1wzYj<7sWR-)0A`WIDFaBeUN^{K<2I+-2@%0icvD!z5E8N7%?W<4
zJ9<aZuOvg|WE0Qa4edaV`(EC(|1E!T{cB)DMWDtgiq!#gE_2L-iRS3)K~T3y^#L)f
z=6BbYR^`eT1cx+~#vA@glf>P@!d2P5bKMv3=HI@1ZaEw%`T5OP(X(!#hWUS?2S$ef
zVIB<=8!O{~V-ag>MUbq({yHft%=j&xdXuQ5xwx9*2*ZT&#&%+j=tAg{yWot@z?ZbQ
zSI|4R(_KwVGeI+NINMU4B}5k%EG!y?Y+;|*LLXgs%)s;W3)Fp|ec!m|;FnhXbbsgn
z2yfBn;NkVeUN7+DTY5@fg{rsfb^E;T?frr0fB8cTTPYnR!J4=Jda~oppEX6l9kz^m
z4qQon`ORE?yZ5wrSLAfKbpa3GNS=bh?La`6HrKU$XE#a!Wny}!`?KC9D&oG<^?kMX
z)<k}8y|%w=AyjYv1aRXc7upL~`z>#X2)na@sIM&I<{t?uB!;F#e0UeLwb2rz=k<AC
zHgLVw0sjXdJG0CO>(kBq8WNI0#rXbLW*vJ?AwwW$jE(KaE|gnJ6h6teiwtko%E>fm
zAkx>p$H3m*iSJ?RK(Z(NXXlB9Lbt3flWR1Nbvn%5yK5SWUZAwl36)B%gaRZ~5GzGV
zUXdRZ5rXkAXRLS!I;w>7;NLz(eNhqaPKr3$2w*)Y^IZWFo#{G9gG&q1QR70Ih_ru@
zp!5R}M8o6hd46f=cZoRE;D=~!vDC5Ul_)X+GYv=?BlZbeRb}FIs(!6GHJl@WrohN*
z8`C1kAS%i^srhgD@xbtmKxd(CuPplW3rq>cQLqNUL*WIooON3JoHO2Q4hbM6n4ECA
znO<?ehw-G=nzEQ`2U@FwL0K)*VjzNpI^?rDhV;Juqs9&Kob^Pc%qh2~O~%oI+7_(o
zsxVMFHXN*m=I$5K{+J8PawlOt^SWb&h*vkR)F=$fhp|VCz|y8ff3zS>vv-QXC1>&^
zhyj8YT7VT22!<T{$76YMZR9eEp;b4cK@H;?=j9cM(~?$DOCvipVm6!BZKnycF*eey
zuX{ynWn|`dCo`*O=+b~JgKSrMX`n+F7Ex@lmxd?nqVALV+U)AVOwu~c;RJ*1<k4LN
z`v((vI15~BwjXpW1u4d0w~<`z2KyomPhIpLznDsdE~bOZ(XHrQqz&aSq|4Q~m2Bv#
zixJnKLo%pV!t0a&(tyS$^|LwB;Km2U({nC6t)yp6)VgxT5-T18;ahpZ%po0)HES~V
zI924pVuTAwqV)_PhUsUm0yeb1Et!A4Rm6-Sa^s3$t}*&8;@eP=BgZ=C*r*G{5fY>|
zOesBj^2QF9km%T#@uf}^4Msl&3M9Qqq{x?ziuWMY_+t=950knA?*nO70RsCruIS;g
zzw_cD1p-rw@$A})_)Eh&nSp2Cq{=QQVy$u90da3;5+le5khNfNT1Op9DA36!E$8Zz
zZ&K1m8hcp8#RF@Ix8YQFt3i7XHlh8%tL|He9j~8c*d(ADgUL-Fd8D!w0SLyLVm!S5
z45Wa6PArjNz0fm+`6MGVe^2puf1O=zjJ)i8z1P_J{QLUe>2a~s%huDyxEtvB-8j|N
zcdtlQpzpH?b2V)ddS2EU4PQK!8C%tiF^l8$Utp5FIQ9Y%L%^6{KDH-o5#cff46BB$
z^9{ZlvcQ$Ao=#THuT+#WK+x=2aVQ<|lsNK}hD*_xFNC5MLoBpb5|l55Lx0Oua3sS%
zVim1<tsnRbNvc9<_jJq=AD>!D+u>;^FZ`tc;cFIFiqnmGnKNp@>$Jy=q0YdrcEwC3
z&Hks%sSN(7EUDE0r>v>u{ikfH&|cI{ywr7^cj9&Y!|$jdT{cR&F>+-!;dOcAb6H_n
z`LD+)8(^2;Sy_kwDpUXdt5nfU1LDm6#qY4HBa}M$Sk)PUHAvqax#qG7T{!%G*F-p%
ztS4@(>LNo}GUl{YHNu%DRxzR%%j9pkewG$oz%qiDVXh<ST>A{5rL4gEAYu3t%&43B
zimiDOO@@a0vd)y8pQ5yj{p1%<&*g&ztHUtQalWo0-9qa`D<}r|ns#=bRCswR)d8vu
z^#N+z0YDd7h2~77ih71?ts7VEk+SAhq&D?hOLwX1B>6H9R<os<Tr?`SMT?ddPCisf
z86LYWFRpAgd9v~hHa%0h4O*jasr&9S4nxXjChxjp5JLCSW;#o5Xv0i00nUlKmP#n}
z3~w2Oec&jp6M7A~FjEqY9(At!7sY<4NhYONtp=9g>4b{?Gl({Z;!`q^BwEO<=6;t@
zZb(DJvO}*0qErJ%c^NP}I`6WRZs}HkYNJ%LY@TgiKjd?6J+^hUewi82afP+q!@m-h
zdN(RgoQjOwH+!N&zr%+jd+8?4P5?97#kJ{7p;-=Ms~hwRcSk1*7fm!y{-r)E%xJI?
z;V#t~YSb5eFyeTH7~>T5>gnWbcfbm=-Qe>cp{3>_6sbR!51JqQ4y*@N?RpES$8n9l
zF%@{O7`3gVR59F!7>&bW4OMuq=Xv$}jfvim31h&L<Wv;zo)pcw1cuIWVivHY^^<$a
znyGTF!+U%XRzU+<5Li|wM_MLF9qk<Z4?2#`^@p7(MN_Y)c_U22TK*i%5gHLJg^Qc4
zTAb06Nhn|G!6@Mdvsl$BRoW+h7hkM6#wDO`b|6Jp<*7?pe^)ur!DJ0zDr(Y@-K%bw
z38*KWZBRaRSE?bsO00@hOOu)ucQS21eC$7VAZ#~+DlRH4(^r7m)iAQm5YWU2mRBh6
zoug9Igz_{q_It*%#+&(j_&V%&<(y9x=!h!TPD5~{HqkVg{6~z9IWwl(A|WzDxg6Qj
z7crLdlwJVPd*rJ`7E?Q=+;(5mI+_~Ya-{WsirGbkwNW~6jlb(rw`rpgIofO!T14tI
z;jlPR$C}5u%N~)pydA6vr9@yPEd8Ef)$ZS|Pug>xT9G-qTP&J1*i&ihO3AFsQ(elE
zIHQ-6Nf>7o`7RRB%yey-uZ=)Wt5%5FM(S_`a1xXn>C{<wO57J5t__c;?-Dyh|KW}@
zO{hC^z1LDia&e_jHZrKHO0ahJO<IA;Y*g)KmJTmGxtyL0bZ0*iZ{)usbj+8yCAh!(
zL%IqKAgOih8{#mXRBb!ew!jy}=Nbn(T`E)R0}7A36#MyBQEQZ6;Ca15Q4--&6uHV1
zpVai6(q-#-O9ow5CrLzj09Ln1ZGxR!+;ni5;sGK$oD_l9Ml4@gxzSnCDa49-TH}MC
z7NbI8Vh3l60iYH#&i4stSEQEU6>V9#_M+!HDL!?La0x3k6hJrF<ck6Lo4Xv;j889+
z_x!Vj*!j4UkviLEXkCx)nV9X>(6a+Vgj1e5)eJ>QWagnE_&HxGf>;t!4U&T%f2=pM
z6Hs0;?R1c&_tuG;Ij+Vl0uMjxdgLq>Ad-5nG$^qBRMBvJKXhSDd;3OXug1LIlB72m
zWB)Ec%;Y;8GpKs(#H{uUOT31au+(XE%K3v8imI5;_W61{1-y2hVSYaC&2xDAwgxey
zBb^O*J8;nOZP%EdUTU-M<xLSPo)ZE$-rJ=e0(WqdC%gzANg*6^_b}_H-a98^e(La;
z>v9%l0eDg9Pb9VCgF!gA6H@-7{=xU8)|UP1`3Y_E^7x_~_ybtf3qJGzyQBUO-M(4b
znK=L39rZt%i7j#erF3%zPA!MlAORHgr9A@yT<#@9jP-)W*%&2yw(Zo=_xa9Wbv(-^
z3~9kUQ;!24osJBat&dO{DzEA82Sro=9g_7e-mXhZdiXJK=1WF?`(q2pbniX<pKM>y
zDSF=jJf5_4y+3ovzqZ9Y2$1M|{{1`-EZpRLXY>6k-C9Jfgc_q2dOjEIl5^;X%`{fe
zksp7RZk0a{-u>+O*}A+RpeAp(1ITzK5g^bJ|H(}}3i$q}{@+TsqXE6-6@Xs5WcZ)A
z$8X{E#UZ0EjIijqjBLEfLLZj|-yz@c07RY*f)RI+gIQ)JQ!Fk-r+mlI?Oa(cBR@1m
zCf!*jg97>9R!~2fnh$rY<(h9V_pkS*7CWC8Tfd{J47=?vTI+)Eidy#>wka+wC;;;(
z`tuX>l_ik?5COSpz21kFvk3isbb;ap`a%2^A4jCi$OHf+yY8_KVG$!<zmyBY*aL%Y
z1R#R92~bdEAOOJZ?%UZ%c>`iVgss=kA#8LSB$MN)i{|<;eL%Sdx~`miD-LS`1_d8P
z`V`7w8UPN|wv0bwZYg}OWc2{62_X8`o^uk`{>WSBd$_{)!_dF6e#xRTMg&-5{!<lV
zDJfg~WIaAUtITG!2;)Z*OBPa#7Wb1<yx52noNE+WqK|tNm)X9vOM1<oDg4(>ah40@
zM8twN6Sr^(VGePBg)^6xRQ^cp6w-Hw^#L{Iq?})pNbV1wk;l9T+sNG|nS$S(mNv=v
z9)qF<dV(hRT}+P!_A=!I)@$H)Qb8CG{A#gAaRs6gXT+OJn_b0|%^$YI;VH-O_sEx$
z-0kH3Pr{}kOaHuJI;`OfhM%~SSHyBBG5ccN7eik*$<;``>FTR9nF2oLUD8jvGxUN;
zl;|NCETE}VpR<9k9M$1|;*$+r5`|=Z&wSYJ*m@D*Jo)WAIOYRbi&PqmM{j8J-+^UL
zW-&=5#7BN@T!7W**-nSkcQ_e`&j@(zu=vn}#mRrZqJc2@`fqp3Ot^WF-BF<$(kOYD
z+!|J*doZH;UIhjq^)jeWmo)}3)ZSS}r&e?yNw(>e2(-n|o{!B#E7szWO)`e&A#fN)
zTP;+>MG2ajkxzHMD<!^^JiGX72i)_AHN*PO6KoX0u6CM7Yb9*Fu9ILH{$<8KSR;s-
zki3`F2tx*NH90Id3NgOg4BRUT_0apvS>fuzpRE&lvJj;JSF#-pa9OvIY4_Cw)-}Q?
zmfIenqO2Ij6%qvNKb2msdO^Mo5SaOdp)NmXWZiUvQ{Vu?SySySingj=uVJLxX@3LP
z2|C?LggatTQ)0D-Z2*OQGN;KBO=>(nxxIXj`@LSbKGX3esy-*K5R14o??-sUu^nCY
z#1%*U5*JVZcc6jV;yxbKc1r<W<&9ul)e9_tXow?s2tjNvs^k4K<u{WozL8bJM7;B~
zH5s=!{zPFjHY<*xGaR^CgbNz1^_WKQ&u|wno%$Dn{fm8OwP-tnmaDD`Vol!cC3M;L
z6Wxfuu!oKVu|e)cT_+)I`$>LL??o^XiCzXo&CNKvYg_Ae4Er>q`DfP?ZA}U(OdVDQ
zMbFPZy%dlhZ*xip>e{OWhB(XHlKQp;N+joiPNu!h)zlyH`g8_D_P-{bcr+NbeuL4k
zbL}Xh)l|X*FKy4xZj6V&CX9}(ssN~Gn?om#YQ0mQBForF+)l`?SQB}{$c{!=I=~3!
z7jN~hTH(1uH|xY0@XJGpCsO`|jeXlIEmT89e<%qU6kaIVP7PCH9#9I{fi=5g8>qoU
zrRqxd%eX&tu^Ira{9!rbtVAJ(x#z2FVgyuMir<yxS_tZynNQ4>FWNV0^G*%WAF85|
z(d{6D3{3a&o`QCyK+zgj(;jU}Lv<FbpD55VupN_|IMw}C3*y%})}Wh3P^^EWxg|D}
zfXqb}G4krk09w;z;R(xLHp?hX!@|*@`<bkUPr2Tfaxg2`nv7<LIgv--(?}vChLuJw
zdiR6=xyrBE7*-Fpsu-QK)mvil$0-;Lks!WmpL#N=^_{43W>wbWusrLG;i%>-7G^75
zC!vzs)V#CTbA~mofp$wNZsSg64jXWS9BAa@Iz0GeI0;=>+io9hLf(S~;6h8|%)k_f
zbl@PAxrv0cPwL96F`_AiBTrdQNm!yhNe*zM4ROpJ4io2TE%^O0X7d;F7GjI-ItHbv
zkeBZEvO}wJBgKhLS0Wg=xE?qdlH~2u56Bv;G-wZ9)h01peXHVItfzB7#u8F}{F{z#
zh}K=(^c$1(z<90Lu<#nxrMnF_=mIpH9K5wJCPAsiAb5%5vZ{GNdbrsa@2K1KgKKL$
z^`Rx&mqjdCWltTw%rP_upXw;Yh|nbgzaIYGHmmxDnfAB57^K-!yVRc|e>alpsd5ap
zG8YA;_roet$Tv5iKdXYu5U%1GO>|_jDnlSSz>nfwp{3_SwGoxPA})xj<pX8R`jA-P
zre!+&R-Ts(bU4^rrkuCZ1lcqK?^Mv0o8gFCe9hew#IH_iWL|D_Aq;tY@Y$EYh5Cu{
z{ThNStnhU<vf{W8BJk3=Viy2rH(823D4j;flX^(&ZKWhIN4Hy;muR+q%sOEB&Xf-K
zQesDGIgYYjugU#okT2XVC4stJTpn=uz#t9_>}vfXJ*0{pn0?PcGsL529L^y$ZOG|r
zNcM6p+eJU-%fHqeQE57D2CFtx#zXgy`XUIKJ;#Rc%ghBfuxuExHJrd(#>p&(OgNdU
zvRL1Xu@%b0Yu&6m``^K?)eAAZA&&td2;|`2yl$Dn&8-&WJIx8KIdupR|KSO&tZ?Sz
z-XmDP-6CPd+E?ImeOJhf(E25v5&c-8vB;0HLM$qL7pgYbD7RfQb-B6S<$jr^q#@;J
zP9+Njr7|5hS~vAS(5*Y}X%Xyx9-V7$O4wY$<@s*JwY+Egu@N2v8I)?;dmGN=w%7>g
zF<P?i4jUUrh*%8{2OMJf_mKMAXkwdNN@c=Z33pR~0~>Sq*7*h68vp9_bK`rf#IppL
zUk!$1qEs)!`*l87RXgl59;Tgr=E`H0eN#YpM)K%-x1u|ql(>|MIW*0HU@-%+lLC8y
zWIF!5=2Ys<YkQ{RMY{(|S!`E*LI_~_^<TQ%h?x};X-y{SHLgo7Zo)_<8|As<rDtk@
z8g%Pc0oFR6P2n{2ln((#UY%Yix26Euxzk-2xovciRKIT>>`T(Vk$j=Kr}OlOrTdn}
zCioIUa4IVSpYBt6En)0G^r_bgOFSJQ_`yhz`q|8AXp(mHF$b1jdSAi81y|~=2fJgg
zHZJ4fX-yr-9o=%cTd%Q9;c3)D);$uJuxB{NDbb>(W$upd|Mm`^=d*_#!#oTrBG6|=
zmLhmHc<`q7gO=XUNFhOMMP(<M80uub-(gY!z=sM2mM4ZC5on+ge8#04-*F|>^9U$M
z1tZBg%(}(}t%h`UxvWLG9s@ev9?_b!x+rHa_c7yv?0EuHDk;8D;5l4ZtowAXn7~F?
zqgic_kIvx&ag*S&?d4E4wz}x~3-F%sk7g)#gu>g48FS_kKCs&q@Zj3^DNI03;Cu3k
z?%O%&_f>K$!`>qtL;YV1@vEZ*z6qFX=b1*M9<&!~(1kMtn-A6(v)XBoe5J=zO6?G#
zHmQ0GE2L6svG7S*5HP+rZsgvVZJumeGq=+dMo+l+>1bX@e!d@OYV>;E-#dIhZ*qQ~
z_db3;M(*F=z8;tX|2>$xKbX#$ZMq34XEVvW*}3oSbkp7(IN-c<sCOM4STjt<N3E(J
zy>J8<u+-oPOD<h>05!OXyGA?*k2X)?1G3b}3l5_gt4`pk-?Z~GQU8E2ZA`T;%&c>!
z$@YXC%o1pCyU}}~;_@4WriLmvaC9-17q#+#DTL_;FFp^P2wt%V#SNTvA>RDU>ATf~
z(-UWEbbFT~KlUy}oMI|WVqG?jHm#x)Rv<LPGfII8n$Zh>uL16Q>ia@*+nN^afEYsS
zmDCNSsdtbYbP1FH{1k=o>GHO6@He@%LfqNK5@k5TaIlm_MAliPRr_2&#phVW(#B+r
z7UFYoq3@?Qt~lk1B(5~r@;E@Dh=95>`>^;&E+1~lb1^Z14sq4D5Pa{uJQ{4eng!w+
zv0q-S@*>>GsEwLPUBE;pkmEJ1V;4fd{uJTzm9K-{bP=YYln>VJK(woeRsN&sAa5rp
z%?)sgxn)lgDcv;ao6&f^b(SAd`-ZnP9y{*-8ECl$&nS%N#<)m(-TTo1qg_qB#3=|0
zq{V>9hBYzW#)n*2(EVdbq?;OsA&2}jkSqt+%4!H`QHb%(A{L&jPnW5Z?amH<9#xCo
zEQS&QDT5IVml+e>b#czjsQs>8es3WvK!Bm_mugvNoDdVOAygQ%4Ld1D%qEaZ89f&Y
zDi}R_?6B4Qk4j+{G{#6;iJO47@EbyMp365OiO4Mc7Ig07;31M8zTi|KLP{?U_Jb84
z(kwNR<kCA({l$74QKTkHscD5;jvw0Ss>b)aSkHzwt+*5gPT1v@10<o?>`KRe)aL51
zI-9N28F~!$V^|pwi}cCLqzB;n&tYj*vEX$jEvs-)sSn-wut+$Q7NycXI%0<h(t1n+
z0DG!Ri{W>^KOLZrFriYC!JcSunyv`no91c+!UQ(m-=u+ZR`wQgnZ4n;OK}-aS;K<L
ze*;E~Z|K64gQ&RXf^F)T_l6;PJtYDUchOrHLtF)F0GWBUgXZcD9oH+0KTdx*%!q&R
zsN)3Ld=yhCqJuM`=h1^(qtLsP!2j{Bna&R-`#vl{3K2lJ7%W-&+fS2JRnMSnJr1FH
zfoO?bs#J1DF$QmUVHkpRaW6<+=eIwwRkk=IN_7~}@+>|n)7jjwgS3>c;`w-WiZkS_
zi0M-YdLaOI<LA=|M|n-Bm-7GH$@FI<u3EBWhc%JRh_~b%AAxYz=FuLkCGHxLsWGCp
z8{(PJZh2V1WyCO9w$;gg&RyX{5^lpd>Fhhj0Ea4T|ME}SyxnEK^eR44Qvze|nxPv`
zZSQk0(UIkSdfTww+|fl(Q9niU>J|R9DO?c!0p;3+7k`2eG`l{-APZMAaX)gX@a7z*
zU8ybXZReg%4B>i}=!@Mxm|hJlcXVrmJ82X`4tYn>g+q;iu>>wO5iQb%Zq=2OCjK^L
zglUTGz?q<u^b=CN-n&|?lz(V!RLPAks&h$D3jh@jR7?)v`=;AkI>4oD;vA5;Kk#6f
zOIH^Al-X>b044j|+~*CnVx-|*(qPmT=~1Ygep!L~-c<7@5q)Y&W0FQe5&?yxHB_ix
zR^yzuTc`%fBsdPcB@D@=Av^GH5cpN?D0Cx)Q(BI_AKs2PQC>XJ#CUV_XSV8e6<ozB
zDf<AFowFX0{?x90Y>RFmAl;%f<<kMLvX$6R3b6l*k%nB2#jMWq(4t_9rg;*sAoG6Y
zEM!p?HpERi#z<uOqx<;BBNq18D@mCQpEVx73JFn4rQqoEDTOKyTrKRilyvN3$({zo
zo^eoyMgSoyALxDjR$<r(P`v-v=<lUM9RMj6xkp%?@3lA5K<Dz5vJh}tGCe|KIb(;_
zepIF6b2Z7IfUuS?1md}*4+U10INz<VbIp~jEV8a)0KybuQDmV}qrQ)dE-S{WWeq~E
zDY57}Jl&|I-*sjlY7YPUwDJAn0@^XE=rlL+?ee+ksxrkl;j_{KjgyXicU?sgUG*57
z@1F_gsx8WxkrUx)Mi=<~v5*Y96s>6W_2ld4JKASh6!H71ZT2eShwsC;ci6KT58Kv^
zXovz>A=!SC9s6g)Ob#vLBk=QX5lUk7?jnHSSimrXqhG|S)!f5}$57-HEJIfopb*aN
zp`^En7mP&%?WkgR^?fd!@-5lHFk0t~NSyETp=?a$hcF^W-%f5L)z(8FMsAUZNyU*q
zMTWF5XN|-zUb2ToQQ}3Xm!_;J6B<~aA^dg9I2YuW$S#j0$(%MKL1#7VDBq%>B1v5v
zwh8wyb|h}J!T*E*G<jI_!H%{oLEMgtckF-X+!t7?e8Vg6{8Q&S)qJ3fRk4VKOCgwf
zPHjd4B^0#JhhAKoEboz}Lptv62-3&WhBI5B8K_a!6xmKQc|^_i?nZ&ew^C9ZXWCPi
z*oHDr2`J8oN9oi>CcJTrcp!s}aKg%3DhtI=DYMIw6-#px>&^#<i0n&gm31SkrcJ9>
zmcrwIk8&b~w^2c+1f6QVWE?lwDXU^T-(Gd1!#$gyBDFVuMaW~G<QZMs$mq1O_*k)O
zcW^7(<+f1vD#MDP(CjnHj&Np|(*$i|z2Wx=zcgc`01X!^h+e=Sp<m%{l(P<{+)lZP
zM-+=!ubqAe$oWt(1YQ%z$Dh|nlP@UVHhOMu0mSYMZhM)1tf*S5Sg3$0gaV7f2baG0
zIt#EaVO$#jOH5bs)%|Sz$0!btAS#H7`qH>NUqVn3(LyQQq4VN_YBnoJh*Mz^<##@P
zta&|5<#l(Q%N}wxWF%C%%?{z{6eGGuxY!E+hu**Wwm-Aw>D8s|tFCnb`FxVV8ZOTt
z(gkrYHe9!ldmf?c>nu?DV@_sAUfCxC=t#>Rt*gjCp6aCPL%3`x#8rCn@+;I@K0S((
zT+0SGqN@IYr7auQpbmP{zzUuTYHT_NA=VS&pzB~2b!!bV_9Zp6wwk4Q7Ru&<uqz1{
zc<pJsngx|>6dVbxv3(4p)RyV!Ht<R9&$3%%UJM6L#pK@mm{Hll3i+lV_di?;X%SYe
zkV^jPJVi1=Qe;i+!QwCzgZUhH9YZh2*iqlr^}5pNeVN2uY&UfK8INUV!ykJ7&nLYY
zAfGCzZoXaBZZFTOyl{>kD5t{ClN`EAcfRPs_k%pmvnhfwO#&^VdA;XlF#%~#fWB_{
zGm!7|#`@UM++Zo;>43pRmP;Z8D}9}g$DnDiW_ir`nJpD@C<d*gkgSD@4FoYSW{JfK
zt!5WvVZma%6mH5<w*{A44Xt^>H_7wh@@StJqb^qwS4|^qChNA!CQ{CdmZk+UEkNY_
zz_J#TAxjM>G$C~g2dt84K3<l5k1f>isU7kgXtbLl{Ya6B2stAL!(Ko5*3bK|g&gmO
z&wqObb=KaBj<fAww-aw?3q<F5@3pbH)4r>%{f9JIe<NbNb%YJILMJ;hDg^8T1Rw#u
z-`1S%!(dB%q>#;oNr?90kVgux(Lx=N9rzS8L52I#*o&_QccuAWZE_-jGyGCddBFI5
z9PE_>1ba+4eU)UExWk^)N$4>m&}j=*zr=^NPT1xq?+d5*@CVrFPWYX;Uvf|srsI1R
zDiMvD47b{QZ2ScjQc@7X7+aG$PzF(7h48S7eVAuQDWo1c$>`oG5O3RtnHuo5FzF=+
z4r92+0K38jGOIO%asIQK*>lchPW*(Vo(%aq>RjD?;VMS*13p*Q7r6zOu`{3Eo&nM2
zuWQ|7TK#9^2T!1R<p@S{5AW9<qz=P-3eS~y?VH=r3u(39;Fcc0Py5e?-Wn(>NG$~|
z9M1R0t>~;V6Zl;S{mhTvkC37VU(+m$Eu^>P&&elHK(?)Vx8_gu_nsZFzU~+J@X?k}
z5$umoNJMAu{|~ADA4VjwaWMX05eXVI#*z+RKi)%LAcbRLwColv^E6u!V-mxSfqICh
z2x$7u!|^`dsO}eZDoGk`OE1pC%o4o9Dr(!EZP^@%4nXMY`ftC3|LlDSf6wRBkXr`d
z*7vV8pl3J#=c6U3<X6FRfUn#A$w}|?nuGoeQ)?iErQrMg+z(9D=zgd3HO*mlh%gd{
zn=I1%JTx59vtKo6sXs!#1D+x;|8QjAUWKI4?|gu6-S35<Z?^x!)ZG6uWSap0`a(CC
zz5QkKO@#cYcLM=@d%WG|(BJSC%5Cv1b06fJ92S>=AI$TsW&IzVTH0QV-@ooOjdB6@
z3PQ8Q>lddk%tOo_YSXtS*zFg{12#ejVd{)NDbV$Kqwi7w^_rW|^L~lAL09koe&4w1
zp^hvF1eF?i`Oa9p(dXd?xOuWWN5{~4@5hD&>}|V>I6$A{7AXFTaJ`|^Q%5A&^zq{>
zq|XQZBVZmwPvEr&0|~Ht0Ii+VN9GTJlNIlrSRe>Q;K}2E@EnQ&VDSTrX!~&QX5ES5
zkl%BuVVD9*%rMFJ*NwyA#`|q+sc_GIzTaj<B0M2jVVeHw;^+HH?>`@C=l#<1^L3TO
z_xb(v-Td$Ad+Xx`<o0T1VnvVsJrW!~beI!R{JAgV=f2|}!uBfG7%OxmJrvIOxyj%B
z0lBTJ`h0-~s}>H2FSF+J_VX}=|N9Xm^`4mIX+3BX=AY4vUsx~@fRr<B|BDl5q%WMg
zj{6z<WA#;004pH~Z;%!JS8kN~Kaxong>9WL>{V}{x1p)kMa^;-d`?(=*(g9LOfPR+
z1UkpQ;RpZ*wHcBV`iAg0fS7>#ucXXW0D)*z-7(Mu!M`VJ?hUBuheuiGf0in8!c2-!
z7<KsC*zmLw8cx6wFR%_d<{XJiQuM2%_RA?^IBR+Y*l-{z0>54VPS-B6k#CO$5MB(f
zG=l|mkx<|TL0BoxQ8Y)4bm-1-2)1V3okKHlZ9y!{!T=#-fcG7P-CKSadX6x79?Y_C
zYQe7~uq5{$Mb{X8atuQRVXttV>*`!qLaOfFiOlG*Y#-Gu?sIx@xp9h3(h~9V5wF<o
z61jNM+t3qWM1tHhgJ&aP!tHy_pk89pBhNh@4UQn<O!URJ;NWB9ZHWyBP}c*1?`}oo
zlK^m)<-`wttfgGXUPZhuIWQ4n7{laT*?<Tm)W25#Y(<>d-GL8@qr`0-kuRYOBX(tt
zMqOqV#O1Caziqy01T$|S34r?&ZhIR%$pdjE>(v#tc3ZPR0AZAEOb<eE_3$+ES1|`p
zi|?42&70|)^{+3OOO&N2<gG#Vb7BpBa0Fxp!cspOa8HKc=P3c79Ds$y1ji9fcK)6t
z;Rud5>r?YAMhGGdT+&RyLI^8H>wNuxoX5kuyAX^SAu4Uy{q{V5Dp~i#%!k<ov0**M
zGcn8N&w92TTU0%tlKg*R1rE8(w+BerfBA&i4y;8fB-wpSfpcy*sk*?ah*~C<uZ(@_
zR>X)FZEWF@(rpJ@ZXMPcS!PLcB{z5WSLH+3T>^6%0EA}I&DglU!^D!d+&T`+mxjaI
z?bq&O-&VCwHBpK8#p~o?7)Bg&$yCD}l{9Al2~au8y%@SMnq5Vn1Yka32nWcy^&_q4
z-VJ$fEQy@uURoR%z6cYls&lf+*rN^=I<oMB;`inTi`bCCkfWx@WwsKVaMISB6Ycnd
zLf3MZH*GIun)^OD8TYHDh6JW-<ImD6{vK`(k!IQ@OVoJ4jq{h|Z3hw)%Hmge=B>m-
zu_ZKGYdjE)7?0D(V0or?#;wChcpOo1IT|~v;1~&~+EaBUhfR9b!FkiJPfJb}b4t9F
zG4%3ZUmvJ)SH>0Z2PL|TqDBuF9=@^MIqOoqFZcIAhJhC2-NE{)I>{TEg-1b^>(>Uy
z{s>Y|CZnA7bR)cm^__Ph<yM`at+<ra7nCUOAYful2wjeUO#S(fog1p+sKm|2B%C0K
zpI^3vrA0v70kiMnL>FTZr*Xx*PU?id`E7}7J=`CU$3=LpSMpSz6YBQhCVJ*fF}D5B
z&fi)WN-?qp$dHr94vA#0Ok2jgch_sTke8hW6#I9klqbI-tRQF2;0iOOYu)D|mU={l
z54X0#;((GatJo&zE~6UQ4Rzr5T3qF4Yk{Thkfv+-RqlkGgmrHUqDoT-T(oOyfym4N
zY$7FE^vp}FmF>irlBt;(XIvK;jf8xe1BR@VQvW`?<1n?v3O5NCZ{O*|w(pkc@{#zS
zHqh(UpIMgZKb85b&MEZ*@(4qKt?nn>O^(tkhzNj!y|{~eu2twh$So-Vmy4s6Oy}ss
z3iN8LOShQq15P|n5m;BQzMshVAqPnNqI`4>Cd)*MD2Oe$W3}qu_~SvT@c~1ntUTc_
zA}o!S-Yg&2V%N}t*)xkIiblaqjG&>e><U<W0a_`8@8LxyKP$Fm%}yUGE?T7+Q+=jr
zm{DJp)THVUWxKx0T%h|#lLfX+C76>GhxWb_FddnZGSZn-DLUk_w+d;frA&hCleWSO
zX4k=utC<6G>4_o<0t?x`u!QL6kCNcakV%X_^qu7SVVv{Qb4E{eTE+?D4flxO(qst4
zKO{PX?0OtfzJ@(bEK{<ik+}7Rg3RD2HTF0<Bh=8gIZc)Ssn6<a)d3fEm7<i$<Bd<L
z3<Ke8ZjQKvCGq1|<akIj$qoM4BDt`y&vY@I<EpSee^(#WCsK4G4ppfPqqw!csLZrd
zfDy4OL>R?}i8payuQHd3naN(*lDof8+Q9{2xsKc1rcop^Ga!TGY9E|3TuS@v0{JM0
zpzKB2AvkQ<Neach*gm|%eNpdOD1pVg8r~^ZHC3Bz-sJ#z|K0Y7NW3*8el}F#jwMhz
zhD{O01g^~G1e*o>XRr`l6?7d<PO;<~o7xL;|2e1mr^M<*?dskWo767er9&MYiAr<8
z88N{t4`)(_pv95~;RvqE2kV{{8a^JEB?SO_3~rpf_Zf+D0B%Jp_@}GPEv3^3Y~yHh
zk?fR4y!H<;k6m-0rO|9G8n)8*S!CP5;85p+A3@I<PqOh({sVJe+@(kXR|nj7eoZ|N
zsfrd4Y~3FVuOpeM=-0Br>Jy>g<b^yYC%!f}+*}FX)1Fp^bQ_rqR%z;JkY*);g8~tc
zzamO;8CTP^mofO1tWN-@{27wA;pG0l2E&SQkOq{~<{^8c@=7=v`P?->AfBFIM6y_p
za;aj^V8mpQaMfC{KkeAC*LlY%i5h9~=+&LfQUja}MgfQ}DJyX#_4#`lUlDKffuu>v
zz5l|;z&3f$sCv)SuVRofdmodAv^@<(&lCd1LIsP>Gh4d<s88@~r;(f`d|G^a>*233
z+c&_EWNls)6aXUi;yCV{AL(LyB*N(Yur?^}`Ud3g&xfjU1D&ST2?$TuG;x>f2?III
z)^@TGfl*SxZU;cQzR-fqp6;y|ZTRd?x%Diw3qxUT$}q6<jT+NccM_tn7NH8t5|zvy
z7FVHGD8(iHeV0-94R-YRhh(HyS>l@yO9dHClY0JI7Dfj+daN!Y){g;DJ5Pnz)92sw
ze4MF3D8pXrS;vArBX!j3L0R(P6)Yi%em06Q9OuRVOMxrSSX=-49GAFGj+*H4xLI$T
zpa9uf6&J{Ik2BI-vjTmSsJ!Lz>tYlnRsb`;9ExH8Mz;@jZ;y%`HR3lnH?q5ggTHjz
z&Vr<H(A$8BBr5(@EAH%5DP{FW0MDq<g-8TTJFY17+TDa$yqHj?fZ|d{j*Ip84~DSw
z&#P3t4xptLDFp9u%ltQ$j*FTB0&IObZrn{+DDM5jCF7}a;>6T^kPmvB4P#mCE<#Le
zOWb_3y>FDo=!KB1K|$Fj_oANVrLU(HoE+_U_cp#mI+%=bxgU5RFxafg0)F-}QRTXx
zWEq;%n-j7!Vv^QzUc;CbTYBrNC~zPaEPyDQzE_F7``Vbi>mrI4xJFp<oB9iL`fQms
z#6qWk3uAN0i0gty2NGtP{M4-JPKNz(2f&<9xgT|oz$}|4%b<vRbE$^HB$jas>J;79
zS`f=lFwVkp<f?am!v^y#T`!G(WzKzFd43qks3`5ySR{AT_ya@E=Hwriuk?Xxz{U9%
zW*}&o{8pZgVc>%@6;|mYF9({S=iAr>kAwyr?YNIac(Wn2X^8ZDP<yvuCSZRYg&S_Z
zJWMAZ`^NP?@p#`B>0M$y|Lc83FvCUeiU{3Sqi{yTWA<n`U5cOQ!rKt-8R3)=312#a
z<9a4iyf{rp&a6I&UVmF#9zJL*TGijlTWh6yLv0il3cHd9(spi5ptQ(qxMe|A=i1OI
ziDeU^aU-B?+j&*umA~sgO7o;v)}H^Elg8NEu48tUR!;SxlpS7<+5HHx=Q>I!Ov4V?
zCOii5vxipdH6B+>Lbf;WJ~zGeP>`JX(Fw}9M%a){*9P#ijFuS3!!=QbL&7Ho2uoYr
zlq2ua<;<Y~Evto{2=%B!F1^dawt(t(<o<4RK(dem2je-j9xrBmG)Prg{F`F)@YEKU
z9d9PAVWY%{(a9Nk^ChdFIC5uKbaNv(u7=_&fD%1{;wqO<bR<Ytq>OOrSzxSBAC+D{
zYMkbd_gmO^r?6Oztb=oeexgWYhM1#L9y6tMMejeGv9hJlG7=^4lkKX2C4D&%f4YjE
zP=@wbJV#aS^sUB#{osqU40Nz>>VvNVk7%e7hq$o$M6mPreqY)`eY4E1ou(8w;X)*X
zHZFaIT<_Tsib%X&N8yaIM%JD1*x#PCSOQq9BqUcFB9=#wnt*n8C0FB7QoDo%S}<gF
zHHSl$T-?n2hkde&leBa?bag19!{ZnPpT#WKo6O0a6x)F_vxTdjq!AKG3a^n;IGJv9
zfC?n#5(^fe5@-!>p_o{}nP%;w-mcjBL_ExU6_=-pPNWGj2Kn3vffIuGmn)HV^=gR&
zE2@7|hc|~l($@z8vgri!*Fr6^T#M6xR^E1Ht*SEIc8~Jkm~Z%j)!@3`ATfsmh7t>e
zhx33jC<R%B5(~lEv8Vs?REDz)OV4?``-4gPGyqhz=ng%(wo4G7Uh8u!VAgvTd4;NP
zaDuAk_pue(4tkyCb({JV`Q*}P(qSrg^_!<`DC)w4Ud=K6$RO0r(r1te)QM2I)`3`t
z@@@FO;Xz!1_`P$v2uq=_liY5!YR-0~!AZ~<&^aj=Nl^tU%jo*;B@@O`zxbBM#8d6k
zG0%e#%1Y<1hX8AhgCY)=POtUt^Tk+anM@Q_+MYJYJ(WrFLs~L<fyQ^lP-w!K6b8<s
z>8NV|YbvS2%lDf(4L2U)><b%Eg_}rqly|tpDt$vps;>&4F$Lj`IWg9l^y?-_l7Y1(
zz%M!~S>Hw?JoH#yZY)2ly5~VE8q#cN9Up@Jhk^^R%<w+8=fZs8B75S!!%{tOo5RnP
z5+-l409GM-l6L@qh32sYAc1x&>7iEnaW+Ya5Zg#*dMPp@K{<3WOV0&JZh-Jpc^=t6
zFP0Wlv8#tG+!tN8S?OOx)JbjhFb7?oplks{AONbH$R98NaESw)y=Gi>REqu!hd?<|
zY<1lL;zX}BtL>oH4VZ-Xu^~zT<PsXw93Te9PD#SztFmY$5)4^m-3@z6#?he`8WwB?
z6CV5Us&GkmP)C&Mk}TXdJ7~yqJSH`1m53Gs(DCJ84b>ZEZoO2H0+06`-W6KB$J+pL
z?z-4vA%Mk>Q-TE{r+vbDQs8-datxhTLqg8w@%d(gu4B+{li^WGy5cf#a9T|-fM$gB
zi5D3vg$~`Cmq*--NULdlG)N`@U$8LH{$bGO_24!P>T)G5`%FUpgleKE?@x70SaN2&
zX~DA0BzoRybZLcA?*{HOi^NuTJ~5@8QMGEV1ZKRPMA9Wq#p)PbyYle80^FPkPoNv)
zw328cb<8Mjt(e&xIkfvXE_y_3rXH+|HWF1%{JyrZU+#n!_ip_)-Qh1Inbp4zg`wnf
zx!Na=Dou$_)m%(BzxMikkc@OLN75ZqE}!4sJ#3{yt77|SR8EP4{M}Y*n#9cL<{S$^
z@aSF6P?t26FBkUqalT1&Ljfdsd<XZF*0Rde{d~(2p(7uP(~&islp=k+SwSw#`Z`a#
z9b4(LN%J%oUd4?~c_Rmt^N4HG`fs>yPLAkyiL{PzDHw{b`opsjt$M9}88h}RU<XQQ
zoH%J{1jv$z^R_PR^}d_#yG<VgNT~2Y*&T<u&W^oqlJAt0H2-LfnXH4$$CX3%BmI6A
ztc)|Y?=Er1wU*Cd6!f&MjXK5oRC0o3h~L1o@{Mv8h~stPadt@KNs>Zp%r<sxo3{tl
zXx+FvFx;@f(p>0DP%6C!AFo#_pyRef^q%cazARLw1^^pE@qLV6b90{p!+|l(B#upC
z_OV7A(1t>?45de-wBBOGEK5${3yU1!h4#B5E|%=h;$ITt=hHc{Mc(WuP4tR7lp_zV
z>Yt3(0m`F@3yiM6IA&cmvr}9ayuytnk@c>`GVj~La4E|yZl~OKktG!HS_*olT-nk$
zdo>0=3PW1rxoQB&RUsp@73g(*5FAulb48QA^Cv?Xr4>?37-vr)Aapl3g2=(OisOe4
zzpmm(4AlMd((|QFxX9`Qg2uIs61{;M^+!*jj(S$x$|s8zTqB`2T}=jpX$Iqz94R5i
z+}<^gj){Gmq^8Z!?SaPfh56x{7X235F3Xr)+DbKD5GrrW=RvSXt54zGD_IfuB(egz
zAp+D%4w#C;hkf|_n$Kj~b7N~6LhQQzZR^s|nj=OMNS<~=Ebh$cl}tdrWXU_S+Itr?
z{LyLR1yOVOoE|EF_DxO$yWS5%q-O18A+Q<~lOE`zyo2&9`4mOt2`&K30}4t_BnJ5~
zagyX7fB+qIJVm7U9y4MWE_KTn6^vf+*!QAf{dc#CWG?R~do>-sVja}AZn40kIIXwz
zM2n^J6K^7yY1X#!BS+A!Ax23xaPXkKH#a17Q)yTmOTcpFNHZM_&c4s8dR8L636i?-
z!Vml_c*1eM+(y$1fJt7UoWb;<B`Y+=Zr7Xc{OT$}gX-&2xAJwgGU!y|u;S}h)8)rp
zM^h-MG+&D<KHmw{d^QgSr^(@}?+DEPj{CyLtEZTskZ8Qt6?T<xX@SC;G32)lVbmdA
zVo7wEb3H(JYWjtBG|?DR*GrqofLSz2BbSAa$+yK=ZlJLST2c`9=P~=)B$f!Zs!>4i
zB*f2SXLLW6`;Gl2+?6lA=rb-uvSz#c34=m7ifpyJ_kgTwcA^>v#`<-QTTN8BPc}-y
z--r$dUEEq_xETsANA?sLEYw;n$o#Wifu`ixrUnbdga#SHwAf6RscJil)^wf{OX<J9
zzncPapSJ4%+Z_E1$)jB9Om32Zz&oI11bq#^vR<ae(p*80umBX7#u#ehXB<)PWQOfp
zf$;3nn)7;UE24}<VLQkRQ&D;oxYaMe{OG02Cy2^xj6~yeKY;JkUZlEB{~)~_wk`Ss
zCZo_)TqWNn&|)z~xP+U{slplmzE^L;@R7DPKTh?}drJ9^)5wCxc8@1m6t+~zth}y>
zn{^yZgBt^?xuJqY<8KpxNX1<s>eN>t0=ay-`8l~_quq$G7Eu5kwd+C6ed~PK-D$t0
z#p!<9{6+Xp3L*_w<rbm#Ks@;sj0OKWMgNB8tPm<DLdBiPoBpeqli+r(tGn~cpL`I5
zn<Kx9b)*<$%uCtAYh#<ju+b6dlMBV&gTw`%q=E^inJ>o3U;mToj-`>)q6~Q#E6Hd`
z4gv3~(YOv$D026J`g3B&RBsa%wDJT`wfXXME*rR{&Kp}^h8iU;=K<aE#*off8|Jfi
zRmK|G70e%PZL({&x(0kF6+mE+16tUn$BlG(MC6Nlgch>bT2{f*kstZAqAtja5+CuV
z6mU?tov2`r=8#CXSm~;`erI`%NC}MbduKvfy0sIb#+gp}tKk$4S)$6sCeKYFWnpsZ
zby$k7MAM@%$RRsb9{T})xFy7qHi*UZ{TGR0u^Vmlt1B^!n~L#9H$CT?kO$hy)ywcD
zpk=C09%MSBq?{!V-w(2Gotv)1EijdM?49G3B-Oo`>!)qIvjXHUwU!jVY_!j?GPrDW
z3avS2j0rTIoZ)o-nwQLZ4MsggdTMV?X`2a4Cpm$eas%2XS~ZFV|1aANFIJ-5zRqoR
zP<iGfeXp3q>kWo*A60=<p0Bl7AkdB2X2s|g3VC!|BC3>4-kkD=S))fw0w}s+All$x
zpjFE?=j%13e}Dmu)Q^&H^xMm@E`QHM74}n7J!6^185Y7y9`($nH4>$`wGszpDht3r
z3?k$kM04M{t_X?OcSKgOlRozYnX^Y(8FF079v)6Ne_Y3FW4Lba{pM?<xl;&Yv=}vN
z!hVM@uo4l10foqQB{`X#YV@nSo8skbZ{&hryL`HG6Qr~4-}4p1*;%1;d`=x7g5sJp
zEl#Ebvg^c4;zO&oSr3PKv^*Q>Ig}P<yZ?}<8G~5<kXXh)T(C+@D;oaq?<018t?$19
zeXCjCiop6`gskje3niqk$gj1r!dHNGbwSgRSoINVTS#8uS2<z7&8<1B2?F`{8C(92
z5{Om%_mV{iHj(KvpvR<H83s5*9uqHX3M!2M#n?Fni4tyWwrtzBZQHhO+qP}nHc#2E
zI;B&#ZFSx5(d)Q_H_C{Akb@j#M(*$1YdO()G&#B{BHj;FU(@IibCi1)V!%yg&D=tP
zePON-^qKa$D$1RFh?bCI3{Y1a50RSmXm}e@OyzR9Wf?|J-G#%QJduwe@08A~tDyzN
zAa}>vZwe{UV%alC4`Aw)N<&SdzMAo}xcm_6mK=H3jJ!&uc;aps=z_*FZ#>_BD6CJd
z+8PrL7wp?+t^FtFk{nbL7t>W5!{=gJ&7ZzW+LYUIA)m~;PNurVj5Or@p1;=dPwEmb
z`g#MR$2IK7I4qcRnaZ!{gI5H`SDn0)r|*{&Li>%mbiZ~V@1Azt9lwb5zMc-2F8aSh
zX(B20Sjv#;eth4EPPKzfzk2;VKmEU;&*mRS>1vcQK9j!Z7y~Q+k<#eb_>2GC#y1!D
zeY(d?z5Jwtef|L2Lko=mx18&L=^kQbVE><6!@8O`zwRObAO9#n86cW=I=w%?eWza?
z1qjJA&_p$%wh+)nBr5p$7<|+guP@BHO_TZGCUt59^(F8LvS`(Qu1H`QhMqydFaj2z
zm!+wE{h0Q%^UoW1{@&e!pRecaM|e2?pWFL)Y&^f;l&klq7$#zPXwKi~?fXby|2wB{
z!y*>9C<9@H>3qijqkK=k`*|IfW+PY+;L7kbzcjp_zqjZ66x?N~{6^maj}8gu5+*60
z5hnlfOa1?aTtnsjF!lfeJ8=2m4@X1gEET%#+nDII#QEpEzdP18V1U7ZU%$H;(hd(C
z|2N}ehQa;KxQzdkaaAG~0Fq)rfQ)1cfsevLn0VyO7aR6}pX|W=I%~h5x9qp!8G3v_
zo<7_|BU2az48IZjrGU+m1p#{aGU~Yb{pTICCBTY+jodppQpI$#Ou#l7gyPP;Sbo<o
zw(S0d!=H&UsDVIiUBP16H{1~cOt)k6P0M-$33*$e7t63y02I)yjxmBF_X3+#^$LWX
znEk$82q^xEoFi``V3=WZ;w;XD+wa&~fUmY7KLZm}F3F`liGN-9`~Q@)+w1v1ZRvl%
zyzu+IAN+iodOX|>jm3l9K5gz@Z3=#HoDyK2fZ(hL)Bil{dV-y}Nie~#xid?O0EKJ<
zrAI*X_2jQA0u^Yh<%wenF$|VmXq7@fCfIQZ0|ETq-l|~V8zrxe1PP$|u*HI5095*i
zjDsBo_h<17yFz&{ZR?k<F8;fR($;4iahg$aLMnJq))nxbPys74FrZN|fFM@h;_ZHQ
zf-f~VXf+kGoqmSO*K&1idPGnG0nyHWdmsbK{BV&svJdOQFK5p%%SA9u?Q)PCcieaO
z8>E@=jRiyA*t^8TIlMKzGu)i^4KGMLi}Sb<l0^Z~(IW0toaAkxS}=K`Vkntei=bAv
zS{tn!T>&|)rm&Z|h-H>dhNvRx9lf>RG=CIqEUwQr%pyPv!IP}99{nKz9ggAY*#rak
zzPWH2%EkZ@t8?kGms%@=igp_kj}Q|oz-h3|g%V-IiDVGB7=hK@2Usf4zs||E<GYW4
zMF2!5Q790<Jtcy<G>_W)bPMx0HxGJz00r@$#{(DMcH;Sqw8095(HYE|h#Szc(UaPa
zo4-t`0V5bdfUW`o2bM@+R)#bcG=40uw}tCm9~UDbaJ`P&&X!{+P0?wqt6~~e<E2Gn
zK2K>BX^tuAXbg(%N<F$XXs`eys7Se9KFAj@Ri0u-W=}{lySGEFVy)^nNj1>4T)vmu
z4D|%Rrz(oN&FToJhw4#6gy_QeP8OTd2N2s4bE0jF4Ni}uIVIshTmT5Q_xOy!Y-RKb
zt?E*%2us>gZq;R@0YaSqk`a?!#3liRO53Zn>rC@5yu#hY#hJ5Fp&293>UfX_ThJXN
zSz2o^L%Vh>;zU%gCQOdItU?rLC+HkMALUTC;-Idcd{Od+>0#!XPNUWB#{lx-!7ZI=
zhu<k2n!88PxAWa(yBGClx~Y`@RBAy<5j1|9%}0;X1ozn}yelIuWQiOKcQN2;TePOM
zsSZ95rZVgrz()^OJ6JY$J|fz)WhY97!C4h$rFw!?{!Z~qoz()mB2Kt#p6KCRzl}Ww
z*BL#Fev;W#K0RhUaHu(w?Vcjf)3=xO1OAT*bjEM8%I4N8023GM0MCh>)jk?b(8ZVT
z)ufgcAh5=^D7fg=s$E|l2H{{4p#7spQum9{p@)H2q~zVTEjAq6*giLE$pfg<$c_ja
zj3lBuQ|gc7wt|^1?p1pB#@hZ~$a(t~IZG99ISnNHCPCC4T?ZYq&@uq{jZQLXpfwr@
z3r-L59aA(mBT`7OZv&~}=E6ov!<B=%Vn>-WPQ(Iqoksvb$1Pw+83mU7q{h!P&mF6-
z&N}$8X^NxI0Cu%kM)??bUmwrdvv4eYT5N(t&#v}1o8v@#kL|fcx8)1$@~{sBmtB$f
z2C963nq2+b`i--Z%Yo~}sIM~NTfK9$->wJc8XKI&8hfnN5Kyjb2yeqt9j&>`jUpH*
z3Mb}hVlrVy#SVtAFCuhDcSO+#Ys``^$`F1OPMwKoWj9k>vmBLkt^_<Bq3MK8BW(D1
zJ;$LsPSY4+h1JnMIIUf0Q_wHdl-dJ>E&!bDNQIc`3<Q3Yj4m+TR#|+v5HG+v+?bp*
zC@gUok!@+qffUPW5nZ9lda_9ny~&X@ev{+tPGoanwBTCtaqLdycM8$6CpaHYPhYbC
zh|_5S1mgDxOn7dz_}fP(YP2ufV9BBz;J&XiLoB<QuvKWlZONuz@JVqUtNTm>k-D(R
zGsaW!5)4T-D907p3T;8arl=r*ngmob$RDjNz3TQx-|lp-ZbAPS$dY2q5?$<!Zp$cd
z%2LCYp3wMG*_b9~f1gHriPE16ch(E6hwUfr9<@c!(x^^vFMX+!sTm`VoQdb5oQoBy
zrYp0lkmPP++D_$fU?}qutF48Jq9je*Y0TIr$)O!VO`2oKAf;&nk32h`bhj*_bIovc
z8PLI{U_^`a!B<dVB4hJBCeKtd4pj#4nuL?4TV!BIgi)GI7B57-XyK+bQ#ZM>o4U9L
z$_1lV-707@j%-TaXog<FMrSb3%>^e`%R-n1A;L%gY$eBC-^5;PSO1S20?aN}zW;(b
zPS(4)23B3+>x~kXpx7RAz{7Tu-tBWHs~$DtzOB7nEs5wHMrFT>N>*cLc^Z_xo*i>6
z!oAxDB?)JWnq$t}7DYxf_eQd%vvpS$<k-hp+Z|GHyaV{j(fh=+(#>k2!TlPj*}&Qr
zQrGS~dRj&cRAwR8^H~}+DdPfayn~f63pe+OYXo-@H=fabk`j><8^p=&pH1tF7mg$%
z2C8-&<yjAssdhuL7lv;E?t&nALD|ZYJ{%yGm~hLO%!`?W%+8r$?aJG5N;1o?s3M>g
z*wS)=1mk6Ks(6_b6y(Q?v>ygDR`Czbx~OwK%!H(~DPThKRA3YJ?W4i1z6gu8YLfAM
zADx3mEa+kbj?F|_bto_Eaw`Y3sWw4VX0s}feCI<^i6-VPM;)3+vrfxBNV=k^VT&rf
z72|Oc6cNXWknTX>v`rCdda@I8Ro_EsI)<=kuN;(^ThZBK`fY)9^BI$}Qs~wT{xaU9
zIzjnT2WYbKroO?mkmU6d%ntR&5eBh>f51P@Ymzis2*NeI8ss2HgAsnTix%x4`G~+=
zku%sr8~4I#3DP%DhI08FFmAm{%w~=LSKd;emwo6Nv>fF1TvUiaF@pJ2-cXyBRdLSo
zZxH~~Vn?J5dJD!=jiIXy?Rzr0h;!ddr$!Lf_GT+Ea)jkXa`ju-B*y~GPJdsRN{S0S
zVW${A7DAYHgQQSrTUe}eMiZHJ>hu7RfI^23!Sk3l&W^7B#R(o8NpG5P^x15uMYJgg
zJt?ov*C(mqzku~h?@<Ac8_X+lzDi7Apm}qFGP^aB9n*bXS6S}2K^gMFx`gFk4i(LJ
zvlb88Ti`01vtlwf!P5^Fp{#6*Buc2QF7eH1zW#POCG?!fV@1@Rh);TkJd}0G`M?Nu
z5WR<|<KRg-Bp0w|+?IcXznK`Ek(KI!maO=j77&ots#bBkpOaGYnnN+7Qo-bdast9w
zF+0f}?d%4vI#9acl)V@Plbv=kN0Q8pNb;>Lben<<sd7`38F6o$(Xv#=QYx5|sibsE
zVXK9biFo&uyNqLw7exL(=G3hfX(P{yl;|KI1q>`USnrv+4r9j(uci`uFhezYDIWo*
z-CX~R{J5dtT!WHy(>4OvZX3%t)j-iKmZVRJQd1O8urav6<UZ0UEKMZA&|KM-Vy%`!
z)`MI-#<&_qXv+Gj4FY9kDT#bTq;0F<H=l7aZw1C*sd0idXm-19`i@3k;Me9pAKhrm
zJL=l%7WtM;K2eR#)v|00PPLgq$Wn|?b7*vd<ltQ3LS9ex%1h=f3;D`{;O4!~fI2n-
z+)=aIje?27E<Bv(m>{MBdm<mkGp2>cB)k|BUWxPrP&XYkUKp*>y`;g%w`MZ~Hm@Hv
za@1OZ=sHiGt%ii;KblPO)5CsU8Js*Sl4#8$D-URe&@BXNg-r%Y3Mc5lMxvtD!Ih}X
zj8T^IqKj$70NKfht`o{rGiY3w^-~>1E^ZWT0wtYg0&1(;Kg!MsJfqvgyH$(SXXm;n
zl2<1~!4~GhU*(4%ON{!hA$(r;K+YQH?7xA^-V)-CJv4`(m4+o)?_kgMhv-BzeWdpP
zFpHnufZo}*Uss3Zz$C(JH0fMQ)~^Mrio!cb%W_xhTM;>NZ51qtawiGS$Iv>CncQOD
zv!l`2q6XI`I3@~}ttW=`0Wz0Yj-&KGwk$^>AMS}ZXz6>W3N&7t$rcnCJbvx#<rQRe
z#Wy-Khi`vE;-Rxw>=>qwYMXqv1Gp%bxEC=9x@#@N^fEYxS#|y*b7g}pj9lhfk{jL0
z;OF9y?nm>eKbv7d_c)Ca*)VwD${Kf_M~#B-8jthV<3sb9(PHUWlAE$d2j?)QBd$uK
z?^7Bz8gN^z^O?~G;Wk|7FrmBQHlF4%qjTjvt+Av%W;Jqd3bsyeb+J2g-Of0DR!7(5
zx*u`+E?OdVsjn7;U+bRfdla4JN@=+rudLu~F<hXpb5Z!$SIy~)H}_+aB4~+DJEfj`
z#lG*%DAlgak4oQe?@*##ix$+O{N;-^#!PbXcrq1gHU@z}u;CSJjQR5p)?3uJfNF{}
z+-6SI=(yUbGhRB95a*a{DRU~UQ^RFN<iz()b%#Zr6+U2E@Y*$VzMLlN!s%~)MK8d)
zG^fTQ^<Y8?Si3&@y87D5f=0n7cBD1aTk&fXR6YKl;E%;DQU^9gp$B#7(8x^;=*9BZ
zzLKm0CeBo{evzV|=jpQsFP5%J*{>udM03}dX_y-U|LlF>|2W1$_59S-mu+n9oX?<S
z_co>Q@PG+Lu#~?*IiojOolUSV<d-SUiAnM`4z0~51uvaJ*4h})Deju$+*u<XM4%<H
z_JtwF1BSE95yJ2ZF{O0Aq#$H&75q4E7R;Vb25H+2=&!GUZFx#X4-F|{W{{W46g!`z
zmV1ogp9`{re$$N6Py341j{tSUIp&+<7lgSw>N}?BLf)JQ3cv@Hn;+oNRL4uwK`=Gx
z6&I9nv9{2)b!S}pKEgfV57V)gOk5w7%uYH<EIZOZ(khCxJ=UfjyTYe$27hLe8nqrC
zej0lDkXP0@0iKkEMA}d$UuQI?aV?ihw8gr$POm?Cu*xkAuK&r33ErwqSC{XyZQ=pV
z)U#?db5Wnpo+X+;jIK>IZ$!7mRHT*f%ibywU>Lbs^=%=w_nh$8a;d+G=(h0OccFk+
z2tGP%(>VDmr{gfLbgk97(dw++McGnUrdDOAQ9-1U_n83g<3{RavB6eW5=R3uaf?uI
z|3#LW279F3<)(4o#0eBy&NAli7ak#X5hG2Ol4ZY)(PBvp-#?<9^y`%fLE-$m7Pc;1
zHjDDv@4Ozp@a(i6n#p@mC<-?bSNy-H_>fZU0S&C^O7y=084PS=qG9a$FTUA)W@dq5
z^zDwGfL{iN2F;?KU)F%F4Y|ZGL#VG+kdJ_^H{&a;+ph4}`m(9(-^=FQlFn1zODz}c
zC~32in$EK1DbyM-c#@P-na-wm5OWuh{MIpE8KQMZo_)-y`D||7a!NeO@@<6|^tV*d
z5d=n|!TBa7!cBx+0xmMH*nmV?8yvrf|BQx?L_keD%dVtb&Y_hfd^Gze8%4-@kM~i+
z!a8}KT7xn8<-%j~8GMQoYCKc>;q>!f9+<q;y`86fl*e^SeZ}|a{%gMCtA7SC_pLN%
znXa;yLaYt_#$(${ZYt{X5%yBzPO@Y_PfL4_QM9nmCE!x01m)D5(?F*)uVK#@Sk+;#
zUK1`<^6F0LvNDt935C*RFz@{+;-Om=@!XNe%k)Z;WBIFF2!N#a)j>OF4O{JScb>m|
zcduGK_g*E3_G7*~byTx5oCnW$+MtUr3}rRC=ha%?XtW4gH|bWBF}$UtS~Wtn$(+`m
zOZ8+Dp&(PkcXdV%TDm?c+Z#8nHbJ9c9#Fp2=gVTC%POt4hXk|D9n6RX%cjMO#tn?-
z^CzfOdZw^l-KuRy+OV<tj<sk|93RXnW7fb>naf^uJ^|O~@qnF#TgT*hAR=osCTn8_
zuD#za9(dj1T^Wl5o9HBkTz1!k%mJLSE)Fl_fjXFQEQor*W2%S*|8rxFMe{Z%@~^SR
zk*=H^0xW~J_OltyO>8^eq}8fy1TV%w?JR5N^teZ(+sOT7uvSlJ7%AM8e*c%*6Y-a7
z%LqsLTVf5PG!~!r*c-1ngjTXhY?J%&E=*P0AgL4R_QFu)9{xE<%-@dPG1A$wX`dW;
z{zc{ch$zH~);33#xhn81x0}OX7Xg7Bqi`6_@141rH>p?MB}sW{Cou?PEjf^e8a_*h
z*7YQZ2p8^p1}zCL!Gm#H<k>%4I_qrs0!;DzeBQR8Hw+#L<+IV%(%a{{IkqFR$I`1e
z%k|F&Zuc$cseTx~eq4lsIn%Ts>d(lyzaklB+S7NIfVFrv!FS8S({|nk=;{LvCxXv%
zm(-zh+#e$Q81f&6s--v0(>1+WdAoGh`QD_$?$95245x0+08d6y6VC#VUV4xkyp3E9
z{f6z+tlwGZD7<BbR%lT_6Z~kfsVLe*_f}qGzK`O8KlOjONB6#d`|r0u@U5TQ|7|Y#
zzcd-JvT!i`Pg0BZe@HD~e*U8VGC&bk;F>f*K>*rmK>*eU&4>wKSRS^-(Hz}(W`SRC
z(MEGJbHO-CGo9*w5@2<QXWTYy*(SMMs;&{xGz~q!yq2dHpNF9({yZI+x21!fozL5l
z=&u+1{<;5j;9unH{pWtCn-3<d#`n-fclQVF@;kqa0%!PdO9?^H()V)7@G)+8bN$-i
zek*)agWJ~z_yJpnUt@0J^!$9i-w5a_M+ffm9+z}TG&FFOWhGPMAK%n4a>QjR`}cSJ
zY3#qGmh|}lkXnqdmsf0yIV1xUyRYly?(?JN{_OwxHuxo-9<9N<0unQ$b{XOh5c~~C
z!F}gp!LvXlEQg{>4HN=IM+0&CEx`Bc^?$Ga;#pSp`#*-%p=s=Q{N7f&CmA;Mj|PSy
zI#>6{fdv}!YS0-Dp(h9d6%v*}HTw~DP`Vx7|2ZE)E5f4_AR*Z81iXYpmjImB+kbr@
ze2qaah>|?|xXb;s6`F^H3KN3XS5${a%rPItcy=f98l$OD@!-XAMjnqt2CTFTeiZE+
zqzeR(D4*jznp+{oUTNtKos1?MtkWY33MLtLw1C7TV@WoKi+s8c@%wq|evpjiCT9(}
z@hUk)0wnnOx`A7#^dz8YQOtjB>Qi;ifKZT=2IZ@vSJjOI8h7bE)!Mq-kKiHs_ag#`
zlO(h#gnY9KT21ExAEMn4A1#_&1mM}57dt~rKqoTb;BU8OD>UE<nzA_cxl4^LYYMB{
z)^UDO2`A(0UHXK5S@Z%hT@Fp@CdcFWM<nrgZsimiYJ`Q+e9q?Yu`&@zMKH2CK`0o2
zU=McU<&*s-cS;~(Om4-pr;9|v#>kxsIZ^4s-v|LYBFb3d)?KZlFJSxkZ(cc{wRQ4?
z4`4{j{zMl-J^FAAVStUX+iC5F1+Xo)mKHa*E(FNG#?iQVa=4LE#%;DE;z0Py&)tNm
z==h~f*;?DRr%-<l(%P2^J}#8pj0T)}FVfOduRA=!w%$XdDv-is02RJ|ok5zu&XDSQ
z``lc-jt^Q^TfC|v3a-FEJc+=eiyxhyg9im{n}??mQMPXGQ^mr!S{^6qVW9%h9b109
zyQjzJq#QSd3wRmme-vSIu0LppJmgmE%Cl#Rx>Vz@Lp55*c)j<IWa`;egR%8<o`r4$
zVz#0uxLNyEJW-~pxeNz0Cn^U((PT(_Qn%CDzp~`lZC?|0Bt#62YKfyBBqdIlg7UP(
zyP3GPUhMc9f}|rkWMeY1`iV=)wERx5##I!@7|!eJza4+7;9Zp=;(Fnc@rXkY$E_<P
zn>z<6Nh@e_n1#2y9VFI4S#4VScd&BRVf*<2oVGH#)@*l*{(fz;_t8?zLE5(klj+H9
zi{5ex#yKjH7nG7!Rd>&Ns$|y8vYW*W-`ZGkNz1aJ^eUVE;kA%hMx6AWw9aUdtqv7;
zi2*Su*58a6!`yZxdvS;-Ye&HeAUX%(Eu|wQ49)MP#Javrq_t1x+V;FNRVvTMP#P;L
zVM1c`Ao#gG0z@Ex68JW>;~;aBbP3BGK*<%OVq#Y1YGebiLa!1LiOxRHKiD+T%k0&|
z4<hNvuz-S=bV?#YDZ`xa;wI!^49cBjd!wq=GmfCsgURJ2X^xI%#QLE}{)RyAlAsd3
zF0_)dw)b{6Fp@d}u);ypmBC3<VSrDE87e)9rka6H55r+Qx1+D24gwJc+_^SEb=2)R
zY2n<w+TIa%O-FWI8z4E4miHn>hr|XbTL|Hx#QJCGU&=S03#TD)BY-%F$5Xb?u$Ih&
zlCUD&qWh0s%qzqD+<2QZs<Hd~RzFG!XV;Nr{UUGFzyR$F#3XW}fh|pDf+MSXUf}6P
zIUjhh`ry5lap@M)lb~=KcqRZpaT?e#lD%e3p!<^5>RgXNRtGTCJ3so5>2+_!!*du&
zgp<ei90A$vo+p1|qfiZ<=M8y>{{7){^(ybCA+dv}-C*~6ZBCX_NaEIIT02R-f)|lS
zx`RUy+T*2xtJS~^mkSnI`R<paF=74g+^%M<&;^bRG>g{?2czV=#-fNKo*?R9_N^gr
z&#&^I@2Q=g9?!24_Mgw4{?Ds}_MexzBlexIr}nAM_GnW0NMLW<4&R$-VXyVo8#r#B
zQmAv@8-3W$e~eHknHo7#l7#6Em8%bvg`z1+It`FPG|d1?D43GNMZJ+4bEptS7LWu4
z$k;r>*C{CtiypUSZhN5P@p@FuiANfUG9)mhjX2ank4c?|5+>9UQTA2n9SIz*HkILn
z8|O*(2NVt{!%pGk4H@kJhDQqiH4|@>q1YW%9|o0P$gJ5IolKx-bJ*}KTmyQbEma03
z?3t<`8ML^=BZKctClq^w7%}lRr?7d3X(>relD;2Lvfum@$M|z=%(&3xee)ECAF9s;
zHkpD`MOgavW!BcNyAfHp&*ULyt1^*bNL2fwI8%rgfvg<;d%=&++va?1iP=Qcs72mF
zua28@&~RN}LCWufWF!NpV5VHm3pR~IZ#IkHilY&5IbNLH6D($IHfKDrB3dPA)D*8f
zusNim#hbs>wh@Sh5-`090Nw_#7?Nm-8mdaOXE6WV^O?=fDU!O^N+u@O_UA~3G-0EL
zd`FsLgGqNYIfw;s?tVC1@S&nwFZph;Y}i!x0U+AcCuWi>-|FOK0JPiGaJNC2hnS-T
zg7Yb>l#<=$;zg)&fJ)djti!#YxIWKyTW02hWkThMwLq>McjMPb(wvO;CyShJAQo7+
z?_YD6qsZivIhXGHmrDCLca47czOK(-VwigtWV@cWz7Do|-c#YpSt2$uD)OtjP~yh;
zdRr#Q|Igj^lc`q@_~qD?E|s*SS0{)G^mK{tw5dS1tp^Rmuo#|Nwq{d7)<6s<)mV|0
z>AzbWM)ml(41(EL!2!dOnNJ*N-s!lUIu3Lf(<a=M4wmU|WmbFgWlAOAqg$Bv<%`JT
z<2Pnizgo@)J*%RlidN(=Cf#9XLD6v+#mY#vI)iLJ*iLt5$gd1piA4Uo=}@!YmD(G|
zb2Rr7+b4i*z4rK`jcsf*98^;3Au2SN7NSj9{?Y{3mkyx~KO@WH52M9`_+m;?T%wUo
ztk8`09wSsAQ?gbk@=a6335IEy&htQL!xMl*dmh>DK~{A6G^DPNMiy@TN!K=2u@3YY
z5SOBYE^u@yCrDl%40Jx4ncmqlHO;%|HCZW+fv?M05Vk4)i8ah>yLEj*Dl`x(>66D$
z46*$)TY~smB7bI05s884L88bGZfh9cjGPctrK_8amojp}Gtnh3#Uxv2WdQo7R2WCg
zIG;MGopcDHz#0|?nG9Vhqtd`Yx3wTEqI6q#pwlmrE*<)NfEx{R<F#{%*0o`R`?ZE#
zE#CecN)ii)&hF+AjUecvk$=5*V$7K+(%ERIK*K{i%PvgMp;^Bra`zI0V&+czh|C7v
zckGm;B?KQF$?JpO3E!T$vSTI-qD#5QUQx<}fD=Q*wRH`5kcaOm&`MyS0K^{NEoiKh
z6m`H^8kgis76c6%rk{{^!;cH$P}%K3Ga)#N1sZ%*WSP;akg=gZxu0n(5)rSMh^*C#
z5JkV=9h?0MFAG;Z)nIg1FjKux;<B?K^&_3zN#rB!w6SOw;#7-3o%j*2$U3j5Y7dos
zkuy&}MP@9|$ZW5|=$BcFxXjm<xxY0TyXy3R>jGNtcCDJdvs$CeAevjiYQmYoM}>P1
za>QMmdLY;?O8yLU-)>O!Sg;`KLW!F9eGBAjcg0&lVs#f3t2T|9G&~g2Y&dKv>ynjO
zafc`B+SfK}RpKs!+z^>ys%R9^n*q-;auCEbD_Jn6lNm}vUY%st|1BGsCmEug3DC0-
z4Hz6b{Ojl$r)PrYoKQI)?5b>OWH;(8LafO8Vi#5@lbJ#V#!|g}?eW-M8u!hhJ}ALf
zSb2{|3{-((SGijvEB_<)S!`9Njk&8Ukz~n6nxGj)8Q6NF;~Tv>IlEWV>NXI5c-Vu<
zHXTe%u^Izood^?dAx`)TY`E5w1?qvmG6$jQsX$&eqH*Psq|J)!oU>Bn$t6qNrCc*H
zW-={Sd|nC!>)Yalc8sXDaAS(<nmY+`ToeT9#p3<}{hqTMMqow1a9Nm2lF_B!$+ZMP
zr8aXAet;Zk`gT`7&8t3ZUdF;RKFO1?OA^N65+-gj4g9e?@OYogsBt6aiSXQaBaFSE
zU~m^2Kjn6H=QUa#LN#_ZEs*O<gWya^cSSrJXDc#RqLM<22_A6ZwEaNya3C_q%|roT
zT&AX=F}=r)?Fl|{un#o950Sjq)cbZhc0>Krw8R!Nv7=eFw{`cmRtIuL(r*=$A)m^t
zUftJB&{8tNaJwIO0=Pw#y7^Vdqt$ZU0@}r_Q_JeOHEQ{amte-L1+Ll3Av=5dPT7<7
ziWqdsz`GrUioqD0fwvAVxcxKPmd*X-a$w7=SJ*;+F*!ZATnUiU^hW7uNYXpmy|9c?
zp~1Y9vxlMsp$5jrFm!MYyx7r0fAiVH$&|?yY$OHonjC8oO=na8lhBb~2a0-5CxmNt
z5WXV6c!A7(`}K_4EPB@RfLPDWnO+!#SbJ-|g)esHEnjn4WfoG(v(~CT56HCR6PQ7b
z4p+y-4UuNzl*YxCW%HiYy;BRxA44caPV2^*=vi!czVGCUxu=zQ%>c@jcdy_ZH_Oub
z0IFHqdCq=vKXZXT{*ul>af)X(>fIK=0HX=Jb(OT*b`Do`v|As5y8`Nc6agQb0m1-~
zCWWrAHhlqLqi%Yd8x?7dP1dE62?Edaw}7sCK^5{}amePeTl_a4CT$$It4CaHL??y@
z5|3ZnbmsvG$Vo36JRnBK$hIQ^RTSP&39V8#HgL;Qm|IyI?j{78u+}s!wk`th8E$xX
z7Mj0}NvOJ;5$x<H;utZvV-{~~cQ()sdRfl_soKC3J<7}eZJ;lIq4Ew;2S$Wj<S>}Q
z7$Z#X3T(IHh+g8_H~UVvqo!8`WcO7x2j0fGDUE2BHPOs|01}OOw1fWp&PGVCM?Ofj
zCPD3cirE2~IAovB!s@1=sX2#)c$~RU2KKu^%~KNfcK`)R^+d|bTeo2($dVv)-w$G`
z?uz2tAroT)r=o4YyGCT|&NcJK-L#*)3X4ZF22%Xh*1i6BgKfG;pYA!V`}GYDfcu`>
zc2s`<+wJ!dIMD0;l_JpBENs#WfWVzg`ckt0*EQUPzePEZuHQP3rn7<)pAe9H<!<hV
zM*K82UMmC6C+2ZhRrZQQlo@k|kB<S2(au&ml%ti%p9BX+SNE2JlDzWw+oYx?tE`F{
z&Q?YG*>(B}KdT(4$dl!1GPVRtQF5=2$)A%{VlNz^wxz4VzF_G#ww_WvRC&5}#VqIN
zTgH(%q;;|x&vOfaF_01G_G~e=HAM(2W3lJ`e^GN{&&`P=j>I3D;AMtZ#&i}Nt|=px
zu%gPtv~3GinYQeC%a6)#ke#+*nKJxGd5l-g<6RfG^|g^QQSb8Fc3(B29=W5#P?nN}
zmrP_)aLOedW-@dxNPO7IbE78VjF>f1^<`i7-|3`Gn~Esi>!o`t4_(RIi#q>$noYj8
zNu#<lac50EN;gKbvc~0wG7cTLfgPt$@MSp-@n~;q*G6-SKYLE>?cE5-Gq1TgpO?iZ
zv64t(=ga1od3%etkvqyCqw?+o&h+}}j&H7&fOuLBoq{TThBu2%dE#Flt(hk4lrjwV
z|JXDY3nT0oQJgb}yuuLjk)C~wA57rWGIbG#;@stkKv@vZF`hVixliboXCdZ1a;>0;
z?uduyc=RS*v_3SJ-#Vk5Z(RD#=53UYxWwU7q>N-(CC=K#Of^uM$Z3j(R4pshU;N2{
z#&*k1@wN(Hn~h44FFxrIr!H$%e!E}_FvESaq)}>^pQc+TFv-w#tVqBb+9rx$!mN0<
zsu<ez`EHKto{L0uPYBwg?@d-sZj3k&e-J&7BxxO9msbWO)tibU1U6M5L`Wqm@mtiA
zJ2;9QBbPJy+D?5ZB-E@8jj289HI1BktO3+A9?SOBNjkhGTn>*(H(A1Va2|Zg>C$Vy
zSOH14oS~dG$6cC6Bp%O7=9IPwI@K+=OKoQrQVy!;gPvBDynRCF=j}dPnaIA&;$G(o
zuaPRRQ99Z4Y@tF&JwoyFZv4H*Q&y_O3|Tf}{kWR#$W?0y4%k!OtZ>QSQ<EWQe+1;&
zMRPKbptWn>3UaZQkB_z|x+|_f7I&Z!#n`^zjWic~qsaVGu{VQqz;J4x^s3~R4E)wA
z)+}`QNUYI$EXy-dLSqh<J0FJFI!+Yit(2ch#(>f+?SH$j@8>;E)(WlceX@P*(;zRN
zdCy)|ztWS%DM>ximY%kXH;PI-=GIIP3401ZPx4y&faEMEoO6LMcCGh7TW=6JVIZ?I
z8v;+a8GF8S+!xkN)ix+QB&c?ZrUy-I1K4$)u%=~lIqBHna9hbOpG|pK#x7A>w-aqi
zzP?;eN9<myLjA5OTtqAN@KDr1F4Mj`?D~Ed_8kuj6yYI^2+G8u%G24%tEZ9UB;jY#
z_n$;fwQW@72Cnx=F!^zeNHbC!c9CVjM0DA$7^n~<Z6ipD2f-ktD!4&upTk2p;zPTk
zQRV1dHb6dO{Bw=2#P9sbPq=~B(meT{;w;&xv9@w0f&HkK>wGei;w&Z0L)ZIyB<aP?
zjlT3xl0-_3BK5I&j8w}^^F8l@I;(uDrPXYNMoO6GFn*n45UH3$Cei|u661{kE+{l1
z4Zq*_{oy99Uq4eWt+~GC@>p-BLHXy>4w5zn&6QB_0<aM}b#^`S!7y^d1N>u@ou8+3
zcslxlOyCTGf?8S6-_83IgnQQC3fEkmgb0aloyrx6(lN=pNeUOzn|lblF4d003S`-u
zvSu2vFz-$e+)EmF)H$+-xEoa$Ch2oshHIR%;=yCU4^KGpun2zdlPA-voDF=fQGV)q
zDD2@rxyqq5;vuabAzl4&INa6egA9n&yJye@A>2Bkgh@BB{#aQ2<pxi55Co2(OheoY
z|1WDk4lYJ2vgcX>V%>(AJ*BlluUA=VO;~;)hp>S;V#rlE?937Q!_;BdlKPgUpDTfL
zY4d|*`c=5=$$j!a-21=z>K>;MV<UvsTgqwpbbRWqQ9{c1Z<|Z`c?=cJ`cW=-q0RC1
z{`!kvgu0*a&u2&W{rAvVbvl=id>o%24uZ6WDXRN>`_Dhm(4MQ&Wudn93I|C)=H7u;
z&cJEv7dLD19y>dJUpE<P_21O+uRp+B%`wOSWnjzrztq35u(SVv16$j8oX-EKXN&l;
z5mZ%a(4qqf1jw(jz?=k-pd0$J(jNc=UH?<%oP)3OF7wtK-;<s@C#fefP(RNzY>qx0
z^75>TK$c<X9fTw^&GLJHynO*jAM$y6{V11*=UCtI|M~iaE}!e?>G|%>_j}6+@5V=#
zk2ox!<NpQt?Cs!v^ZmN3Iv7aZvN$|ivi;w;9xp^c^vLF(LAn8+Lyqt_k^Np@Z{I29
zD3-?h`F0z-B^W#%B^XI_`8Hnk4IQu;OHs<>e;9iK0e;-xU-RMP@lWJ*dDx<oQFz|V
z%Bz##<}}F-oDBRK1RrahF2lP57Q822hPZ+RYv3ul4mDX|SRxaU!R|l>3j?5$fjIle
zAJppge=Z)6XD;w}e)fhymNwh@eLVCLh^Nu-7roJs?T9%<0gZAEI)nLU+>?M+1)|2V
zZ->LNO8~|<pWGi@T`8do%3DbTi!JP4;@3Ta6#6(PQ`wdg8A*EVfDabo9ftuBWG<&*
zbwUzwkN`kCeM--ji8~E$aNHhwqKpkqCZBZTjS(Rsh8|#*928~1F3|Dt;q@V=1v)0d
z)=xsiT6~7O$6<DTpTK+yhL}kp5VB-u#cg^%te4W4y4R$2@b+|pz%)psZqmp_&;tN@
z)jnKsg3rg1!Nv^6dHB2`k{=}2+3@&rPJpNjZae0qmTEbqrKF=Hu=HuX!Y2u@5#?h3
z9uQ=fs%n3%4tbH`N)YmwDzFpU{5epTYM9w*4hLViD_MIs+fF7{SioJpYa1bwlp8cZ
zu=-GQd&+<Q6oKHY{9Bh_@9WRR3BJk~Y>!v@ZU?lD81>G}jU<AcWcD1!6ov-)V*^jT
zc8L8~6i=B8)u*=d9U6oYm+T5DC;<3x3i2T2?t6-Zu#Tk;2#)1-fs180xb9T)10P8}
z@O$MK)v2l|#MbDUjWL}by}_g7d4=+ltgCjWB-}?z5SEcTJ6nGQX758}fRwefjXs@S
zGkAzJoGrKP1$#u5vK1OvP=<{yBuq?KLNSI<SFIuc_v^RH)M!-N7C&ZG5xzj!&~^>o
zI?P5`Z^;u7opA7OPrIOXK+KQ{in&KrmKMGq_B6>Xu(9X^eN5?K%mOd5WH7PheczdH
z5i%$Nf7t@<1GcUL7`%&rX{jXqbz54LbQjOkd$+6jR?9$_wpdUQuo2Qf#w-?k*hxw&
zl~u7cwjK_8DKGE*?k%w3Vu_T^>G+RYE*TICrSODBgB01g{SGv9yM92ef2UB)C9nH`
ztfjYArmhf06;n+${w(tzAMli*ERY`MI4Y0LmcRuooC3=K#0HxSE>T@Dh?=YeR<#8N
z#k*cUO53kAk`oMuwW@0|q-$w=f~G!u-cJdylQKIFO}Qcm(j5ftVu0S7z}LAwc!|>j
zs7bmVZl(b$I$>P8z83~6;FM4-0>koLhKCjRGa&+a_38Mi5+fu7D-f(7kQ1dR*rY_4
zb#<9ApA0KEcYy)}idp3auSz{`pojy(^njb^8MbqdW6qC4Ea8RY2suc}Bs@@}=&YKO
zR31Du*A73QVGaagcUG>@wT`3x8*fuoak74Q@>K-jh&)`%3kAItO3CqDz2d}caFpsx
z&2ldK))Q)r8ls!)jR4*Y;H_(9Gai$!;+FjQ`X}nz$*OZKY0Ie6^A`^3;1Fp3@b}N}
z+u8N%fj-oHCeP6*@<{fin{2HHlFx7Y6u@(!*&N#B9Cko`b<`A_8c#o-kj9!@BZt2<
zgtvbA*}<qBDnYwoi(crwh$-aXv_AU&kym$l6ynD_^#o7ysd$XEk>f7#_FsbT+)DbH
zMS?-LW=x#TYc>`Y#x>{=I#d3bt|8Y%O{ayN?Q*}2py}&V>~m5X6xPA+>IBht6<(wu
zvv-7&#6<aRQWFb|H~+UGu16=XN3V7IeQa+#u4d-%*B$@2r{4_e#_#<X6MJNj@BiKJ
zFJqsFm!Ai*8{Yo=l1k=1{EM7~e4xBQyFU|uGex9>U6f;&h4;X=!=P{Bt0Mp|XfR&d
z!#e0Z=47R^4zKCNveMfR8`re9<{X0gqacQIQj1Drp4MbS=I4m{7j5Nl*VP9F2g(bd
zrD$#Zj-)Pq=yEGzln5|6USoE<7*Q8N*28Wrb%*u^m7Hcc%VupN2pt%dYW;8}tCkUD
z>W<~|vChXCC8vBByi@N>oX_lp#$z2j%jCHa0j8s_T`Y(biii{Uo?$Nw3y}rh5Ke*H
zqsW??tedvgVU|G0F};fxZ=U?~g}W#FBxi!oTj+WH<gi>sDi{mB{I(?o4)}C2=>0vE
zT07E~EGk{InwofaVU6N;Urw8hpQYrnKqjT=lZOWTOsQF9`qlYRKp{AK!o7v2D_Ko!
z188njVVqsv4S?}s_z-M842JT`uP>p(zKls#_OSSnrsAk{w1uulT?`$W{Jbf}XhtdM
zge_%P&TWxMpwImBdX4JiZf$EL48_>}tMH!6{1gkNdfpv<<^GQyM3^5(l5JCKAsy);
zP5t*s=bFd*!nh^UALVCT8<g@RPfI?QRW1?}Kb#et$G7VB<+BtrEg5Ty(Ap?X;93d6
zNx9IMX&)t5MHcgPRoSX%lwiB1@{xqVVo0R1tBl_<NF@2)PFIv)uC;O#jdfzYE54wE
z1lEfTqnO(+<#x=y2)#f`o##glqv*i7OjqOUMTJ8m$zqgqj{<^Ax=T@3NHZj(=wU=@
z<kCOqgAD46h~$6aCPPPG_O?~NfMcs)l)b98I!VT=hlxEq#@LQw)YDBAKDY~XN181F
z@T2l9le9F>7i{}0OayAhac1`48R!<)BDUTo8Nko<QuN(xaM`ph2fwsY(&VlN8DkeD
z;bl5#S^a=eG3&H`1mN5ZixGy2EuqF%P>0Ko3R4In(&!sEY_U-I5KXN;!=qWt#Q<_F
zvCN5R`7v$-=_Tov^$>Xti79U%s}>RpEenJt38|Znh;YnbWXTwsucNy(IQ<xsv`sD;
z@y%lAym6K$-5<Rr8Yb_)<Q;!ku}X(fZDq^gKQWm2{Suwgu*N~5@!?QtHn!6tS2ozx
zg2Vr6`dE<XC?bm~ciCYhnz3a$>&(f<FxwU({dYy)?kPpL^o2}WFKPb4;4IP|B;*Ke
z|GC5uFl+wXG+jChS=(Z$c|6!T;&7bZ_SkNn9^%Wh8;4TA=)qn!yWUxbv3P7$U!_>x
z$_$<^;wTa;H2^6lqidz&1!%SGd>gn6=R#1?6sRX6(;!HjwMCaE+AiF_-x-Fk2v^w`
zrg5;LNGiRAJz4y3BLkC2GvCEN%T|-)<so?4g2=14nXM`jrKp%BRi{e|J7^YXhZ8|3
z0QYW@hte8xM2P{MqspDUFj{et&c4eQ4XQ9}<H0Ek+;#&3bKRdr-p*R+*QJBwds}mm
zz!l=eYe;p6m5WRe0RD(@8#jiefY}QjSSk-Y(5w`(^OR681&=8)jzht#xMA9*+g>Y%
zUZmk>oOZO?w}ix@Hs16)H8E!1JsJsY#!+r?C8q#wm`T)rkPA}l1ZFzrcU4%Ar!%qu
z^>diRg!>M=@z8vI{87GacU{8K?Day!EW{%2*B1NTiimb&;zR*8URc-8#u+EyUTSud
z1cIIz=492*mV`WQ%?4|-Cajy<c`R01ClzaLuyRC_e!YrizEirQvx-UiPVrpL&9hp#
ze)4B;SA{jr_U1I`El~bl{g@<opI3*OmJ6yE2Pf(2o7^?9W#6r`QpV(gPTjdl=diIt
zv7MtDD)AY+CeK;8B)@vIhHp}by+FyjsDR(gB?pA-N!$nU-I#O#X%R<=qrR2#e4z6E
zr1!8BoO^NpZ$#gd13JDXr4v=gj50<&@d}UJ6Ueh(*Pk+AGUJAM1OW#pn^ye~fFL~p
z0iWu)Yx|`?J#@`&`SCK&_k>rFUd8#&@RaB}-zQXyEsCJWN<7^}_Zdmjp%Ff<|897z
zqFdjaIXA$1rg$X*X$Jr3XZRun&vf~M8Oc0U0(H`Mn+<G_e^G#^+oNjmw9Z}U)9z=|
zoTeUlxv!Zr<!dKTdDn8!OS|0JK^Je!=T_H@@Sf+aX71;dD*Qcnq{X!6Td}rda~Pj6
zOz8-p7*HEhB(#oe>k_0HQB77+(y_Lk_UX{^yh%hl?d~MAAzjs2lE5O6cHs--W*%VI
z%fU2RR*-3FVP=V{4cvaoiLsw@Vz8RR8)cu3xuMa2w}u$1k1-P=m$X=&(wfYV)xr(L
z9z21F_ic^4zS-5>kv`ry@7rgkp%I0hEoOMebolNDe1XMqNH<V%5%6_&?XG%5k^PGe
zMzm%c@#<Lt@zw4YAc9N{S$t%C)wq-<g6!w{HYck?uChJj+QhsXrbJLY!Y<cD6*Zm8
z1$j(k+ae?B1=c-PEUN5&d=}P;7ynZ(O~RVQ2sx&^DCyku-u6;>H{9#C8Q9~Qb0Cp9
zV=y)mTHs`UQTX98|DnFoqp$mEm*k{6A=8`=wS))yFOI`(=6ZZb!jCdq^y3rZ#nYCA
zM)mTeV{S`yYeQdZLeENmzu^oikKiPW;`zg%c6ACCkPEJfx-pZ0gFeCf0Mn=DLYXpi
zflH;w!FI^IS+m*p5*lAYTsCSaY1APlBz#?6F|$0BcgQ=OQt6VbvcU~O+LHQ=->$-f
z-IY9kl`Wts1HOL9`8-?k<l}?}hh~ZM0rr7$;UFc}q#3|{IqJL}C;CHl#HzNp!4VzF
zx%6Jm&<xDwlvHVTx<(ZipM&VsFT8PUZBjaT-9hi{Udjx<QSc$6BH0}Q)i=Gu6a_@B
zE*Dc(g+JyQdU#S>ehAtq>J+2!WIiOI)YSZp$6GUk7HW$D(ouJ@IZ()P_04lZuB2S&
zv9kN`v_L?iw|r-Mdp(wV|6tPbLzHWr)=oycy6;<T{pxmv!!~Vm*4Yvi%1QQ7BTQK8
zas#9MKOKUDSC#(xCU6B6gxp5l4+WOEB8qxZ^~-Ves8?GKO?HCV$p}mIgs3V}=KgLC
z`h|d^TtA^EVNF)>{$CM^P5Azy^(Zx58qT@>2tgm)@Vi=_IwRa420G}Pu><a9C{96s
zAEY(K3)HWQfPA+I*NFM>e6Fbc(jeLFU~NHJ{VFTKEpY7@d_rG{N_E8*BW$Y)ii3(M
zwXUV{MO@Dy`s0K}V7CFCBEtwLz%jP9m^2^WzH}@C9aesqLF2b*Yvchk<F?2baYC#i
z+@s;0ziVujsO$Zqj_%?%V8pP;aQfC_#{hBr8g)Gl9I`m?37oM+&i>yDKkERZ0A2be
z&kz;o5G}_Uo$Deb;Sv&@$seJ{pzkJ{8*dnH%xK=oN_11@+cziNp}p((`4{5blT@!8
zD9iLGLK4S9X8Z+bdff;VZA4c-EVl{Jf@_uVk=_Am1}GNQTZ&GMVEJ8L!9yMTRZ|{g
z65?A+j+smg=kpM=QJ1Q66FplZPI;J&?Mc=i%3DHf0Fchog`Vh2;nSVImze0u3)vIM
zNAh8ouI%8!fi`VgjbQeg(3W6k_0G2!YIawvVHG>|?Oh6Ht;82XdqMh!Kch_eh@z=E
zT|6n`0O*P>&=Ye`iT%WH(E?7qSYv9m=OVtn&`H>&NzWd#4xA$d)t7wCDdGz>^jF+Y
zeh(6Mk&~~Y=)r=XP{!LC5zKB1r-M#EI$}bP`$4$l8!NenVCw_k>d3dpTbqag&F>%y
zv<eP$EaODsrYx}c9gs64MGV^dg{&9~b^6LKoli~^?~ryg6|jdwUAEjlwhm8U?+<@^
zJSRxZP{E<Z`-e>b+z2pNw&f1%^z^wsr|*%=Fh&ifM3f~AUOqS?#Q3uNe!uO>_h<X{
z3TV=k>sJb1(z&#MuP-5KarrJ!B-I#Y(2$nSbBc)@Moqw_Hrjtao(+)Rd>vvW%fJQJ
zRI9JnEh+XqJmf2l^%5gB0*}LQY$LLQC~;9nIvhGy5#Pm-LrjZ*7FHlS2=Cs02WU`=
zEMI|45|gXriV3V~X-T>>N;I7-IMfAI8S~V4I2Sl2N8=1a>h}DroWXL)TWa}YaLm(x
z`;<2PCt7n{9q;I6Dta_Tw9^(TFri1!j5)kF=tL!>evAH4Sop!NoZOQb;VaRYQ~20o
zQ#aw%cf9y^0ad4PO1~l23dE~vddo+x$=Jn`pJ19)7_js_MB?mc`a{)u`6%j6b2Yy2
z<s8+0Q1W};^?QB|*Z6dTipRBoa5!Jht6U~;zN(shU_mbXb+s4oJfi=hP|{4Fqr>;p
zQ*tE6_3`TV^tn{;k#(^mmybvEXKyDQyNZh)5uUyMXA|6PKKg+&hE4{n{EdGTph^}t
zLytDU5&zB&<MAn<Q5OH(8tr$~HQFW_{NF}h|4WM;3nTOYXOYvb$6=52?e8zba|dUT
zRYD;J3=15_AK(L7%VlKv;2I|zpd-u7yrf~^_ZLugRd?5~d{XR->+OVdxKi0tsw7Dy
zf`_Nnau_%QrR@;eJL=BI`+f!(IH@l0@BcUpMEkgT**WaDcsm*kPv7Y{8vF5W_#m7R
z8n$~o`UuCz`##vSf2)$m`%D5cLb@5Z`@VCZnq$A>*3DVNz69F9{_B5f|N1^OH1%Rg
zsLS_xD^Pxobg+*SAuQ$iW-!<POIK5nqNMqKHlCpo*H8C*{&?HI<GEd)whHryxSe(F
z;`5&;RmdFx8~9QfIU>AI#6jh|IOxCKM8f*tZejold@KR|IVurz_@qE0(Q9bJK<$BN
z{VM&BujkYGQM>*3)m6~c#cxT`R~b|6qngRXezv#o!vaWEaM8j2^M*|ju1Cy7-6B|L
z+%^F?9fMQMo2>mi?I9N;5k+&BU4n5(fk3n*W0w8(!iQKODv0JJZQH-KH6@6MlaC*v
z;R1LWn3FX9cuWAffFKer>`(uUEXi(!#NxM{R{xlwkRZ&-jn9kSha7#7%mxm?@hs*r
zNX&T66Qaj*_Q^&569>x)50`_WuHoc*{RO4qa0D58dFtEsmm9Hzh|vZ*))6*L1`1=>
z!*BIa^x8h3gLUPcj9Dmx=ojQ_vyq0F^Dy!2w}0Mhx2I#JV`Zt+rKtYrk|d7}yuE_(
zX1hEdGR>c~$!*-w7Xw_Nu9BssV2usu+|Giw!BK7W6eZ(QEr6<lu<&slTcuV{Rqt5a
zcQ$j3P7a2ja`(Mx*-}V=h$*c-)ZMI?9#PV51n<}#7?@~@-`ZmLOGagjcDa)*tmi&#
z3UPD+?~BaI+8Qdgud<t@%k87g!nrv=?se%?#Z^Ed7e`~XY=GmStlh6AkAK#5G`*|#
zS60U3LbE)HVWNg8dIc^Xgc~SCiH!$-cemC-VJMo$6fb8>l5DTfuB^t4>aKCgpwr%*
zOc4281}lWY>5*n>61=UEth?Y7fZ1Pro}QaWdxnTgjDo6PYPto=%cx-4TG1__D#<1g
zEf|)lnxT#0j@{0fb}Hh=fA7q6nOp7GQPxHrlev<0WZ#sV$Wcc(U)C2fSR}kyo1yBL
z)q%9;niXbfeoLV2+;%_^LCD2sXmRcrwH+hRYOa%eU!qnrWG`y*GY5c-IV`RHKaAZ&
zlr3SGCg8Mf<K|7<wr$(CZ98w;wr$(CZJV8cbxpcg4QhA>XPrr`i1_w-_xpTV?kG0V
zdGa!e&@GZ~=`z3g6E*LdQklP<Pby0_zCVrIsCedL-y+njlco3OlqJ0VcyvJm<OUup
zkvN?I&Jy~cB+Ki_my-jz8}sHX8?P5`?kWfAAyA=lA^+o-LYE<Pj`kM}6Q9Ee2+86T
z8l2x$PV!musmd#L9;h?naOJee?Y=69B4V3Cfj3ixhN)GRC?XcUC?}pg#p>ufvByOb
zKu{?By68Y9q|AjvFFsvSftgw1ZOTW5HcO%s_wcP}U7W3j#<|_<W`YHg{E)%nP_CL-
zHG%9fE7u?amEw06T6#Bid%@fuV(H}U6qLrOYwD`TV!8s4Kn29*bcG;Ww(@A3|Mvb?
z6O9tm$53S|N&S}`F#LrZ)wiE4eBuf{48nLg`@B@#M+Z};e0SjH5dd7^xW^*3448@(
zrs@kqX?nMd64`5}S{NZm@<-XKIIO2;TGN`0O+*(-!WW7!AtX^@gNR4kH3$Q7>)Kg$
zs@LUjbiQ{1-kZpX)s9-kuyV@MH#uv=a`S0RiU&|MM$9S53HK|Rza|#4;w4y-D)ts+
zOUc7{`G|Jod4URWTn7=101S>{<{j9YDBp?ssL-6ctz0vJAY2*|xW#V=)2bphi59eD
zPJg!asZ`a5kf<3O1QrphJJnL(*>8_=>OW~8FpHyI>(j4U4v2pjyQ9aQ{^QM#xfvTi
zEFE}iMXk&Y-DkoC38PdOdr^F1R26G4C3;>){M#?>+x+)HAqV?_H9Mkm$p(c{tZ$ap
zua`Xwg;}oq)x^<CjrUl5>xMlwu8#?!ajEnEW73dJ=7@vW+6F;=VsdB^S)n#zll!LM
zjWLYjt1-uPlcfcR1o69Z91;J{!<uZ#Pf~@_1lPFHy<#9yj}5lY6;z~Hv`t%AU&xW`
zn-omsp3aGKvIcf9J`_cx#zDIKEGT3<hyqT#g5u3(8<xcySThO!igV3lr;`Xhxc{gs
zzFw~oLp&KwNSOG|0e%&3C&sD+!ahgG_lipAr>^~hJ$5pFC+4#|-<*AHSxuW^nIp_N
z)!Ut1733Pb<#Y^XQ!rP&XbvOGV0;n4!u^8`tT^`VE%7g`o*Vh(wVbrV0@?+aE?kSn
zR01XB+f0S7nlweLjg&duAt(yFF(iV6fg95c;~?T8#RfTxph(XzM<?!7MQRMtBZo@#
z!iwtYN^{yDE6lZ51!@<zr?bJ9*}4b@z6GFW+=Ff&4OBw#qEDI>-m8lS!hv9JuqF+T
z32;yeHj83&*(ADJ_pqUNhM{DcC2?|^LZKvtw+VYP8ZT&Q_2U6I77|Ak>hU6B9v@!D
zcn_v0BaIW7p&1S%7BmYYuIO}yXOAN{wSf2<0zSv!nOc%-#sr*K)#w>T63I?J!W{kU
zuGEaqqb%BesIZr&C<rwh;YBFS!x^VU&+j~MHCd2h+!|4^8_CYFGumY~9taU%64@{a
zhq#T@i&fC4sk4&@%C1G%Vq)T<E-YQhP|lp+kCWXXWv-BNX$-xNMJt%r-?+LYa@6Z7
zyjh^f__PT(i<-{3u&#Gc3_@GZKOlq&QDl|MdGo*pH~IZp1D((<CbXT#Dj!L*;yB_@
zOuMCjMUk9ZMXX_BD@9_8@9Ra5kI(P3Qg!F+>*xFN1b*k|;AW!d^LFQ_z0;>FwXekQ
zP%;0jt%il`W`i|0NxsV$ePXnzG1mQGFan{yP>R#0iy=^YgiS=zx98jk%RQY^!%#!G
z9~Y7CrQN}Y5I1q|Oe`W;31X}rr!XUYq0m)j2B@;-O{VZJH&HO6afe5unR?yx?jyJ`
z{W3~$eBml4n$i;1m9tmTkabm!l|6yD{p3eRkv%WCRY&jGiQkoD@ADXNvp35O3db3N
z2Q#If06w|D8g(S0_hFBdlLIq|fecYzWci=0uy$c9#WZm?q&n#c;T0nS18l^TWA49p
z`eZ3#k1eXbhmt~T>rJAa_I_1Tqo27&lZW|<JS3?q)MN8GQ%&s3+ZL@wiO>2rZRbs@
zofqV|36<ZYh<>yPgBX$o`p%e2sv69Z?re9tI^6jJ-d_;Ll9RL!#I?o%@RO7^gZ4LC
z>5d>zmp`x146QdeJKn<2u@Y>1uw-_?gju9K^!Zwc4b2vMPNy>LF)#*|gn<KtH<rQP
zkWo^HgPDlB$XroLf0U!@AnTc&U5Yyhu4QX0xArrsEFq3d|6+!bhW(TO!5wrYi|6s#
z&GVD2R)ZQ+AWxPtYUR9*yV6MxxmvUs(DbTqjKzcE+N3JyzO^G-9to^4x@{f61fDNw
zW1x7U#DV>HR^Bwj(e|CFSR6?#-;R0AZn)li0+=8}yW|+W(vP@EYigIqk?w-SwehEb
zND8MWc|mistkq9_YNcy5wJZeMl4W|XopKCQwjlF!d%_D!MX5&Z(sq*rwy9Q5S7Y9|
z&fh{~zO>6Nf{U4064cAU^{;y%6V|)B%%>N{aGdarcj8#kEVV6hgK0!?SVg*zqwxCK
z9lQDgKt&wv#jaYuC=X<v{=|TMm_{Y+>Xz-;l5m8y6Z>|6`RpCb=&=e$NA$Rh4kDnr
z)uBCe`fV}LwfzDVDl8{-O<WO-18`&c<ueVSCw}NXhZ)OErH)S_kEn7@iwd@L=Q=uf
zk_BwyT9cRF9tb>Ma0F8U_0K2$qn7hQ1!!Mrn_v$3brXfX>@%6HaA6nXtio;{40^;u
z7<u;Nj&+j1wJN=apMP@fSE!9#)m18`nO^3iDJlHC9OA`E$=|IqzCYLGEF7@IX32mQ
zA?SGYOnB%gx^)=sVrU#uLxm83>L3aqf#Y3bf=nssGjh7^#`LL<!^O&hnWXj23nx_`
zCp2srqmC+zWLx^Caa!p+b$QmnGOU$30-y%1DiRVw3>WoU75y8*e4{)@kq^HmbT#9?
zrM@DmZL$VBsRJA9N@|t_B2Vx3EI|FO=u8IH$pJ!E*@RA;zh9i7&KuZ#h3t8BW(VL}
z62ykAE>Hdh83NI;yVsTebr~I%prhBxt?ODR!b~17B6HCk%wn~ujtPIYO22Ce^HoCR
zP0z{B6b67P@=Crfp|GK4U$+kLbZvGSn6Qui!3B?G_B7#2S})5ceDgD;@b~p>EI)C~
zE1nL<5;^j~)E~4`$Kz5DI9?1BaGE4;D7kit!keeliLDuj<cx_^cQBR9<l40tg;kQg
z%OM3BO&yFmPmkirT8AiJmmInr$;;m(BCCM2p^P;q>2#cr7#nxRso=-L4U(H&=#24O
zm&Xs5mYzGs`pQ_BS%{z*2RGN?H>`_hwaM)-J23pJg({JW41Zesn@4H==gO*$+Gzed
z3SI;dO7w7)9IzvQ=ni6$H!tN%q-wc}_I&?4W{sXlN76i3Hno8=)g5dk04~i$j%(76
zGB2~<!>$STBq7VCXu>F^8<I!!N<@1?n`^JVKA?xAg13MmBu1mHN$cpF<M$YAAdpU<
zCJXKlpEh|t!PD8UC>uSb+5x|8W!)rAhf8f;thC&~sYZ<;C)PjmJL#RdvlR6)0oJ@p
zx8$>);6hqynODSWO`YBT3Eqn9oS7J!i^tn&OAD87g1aT{Abhh5Vgh0}Rz?mZ<j64+
zTN))DJmftn2x9^=q{``9qkOU|0~-94kGZJ?>po5++tM`dY0$Wk@{NkRnq26Jc@qWS
z?gVJCD_hm&E?$Oit2tq7O`~Y&BLv}8b`|q8byUs)brbT-xh1PhL|p6WOx{_K*RdWT
zO7EEwZtfS#o6`smx<+|Ixb%x7VH`fhOF=*(BR(D?wdDx_@`x;^{pH4QM|P-rcg(;`
z&|@2w25PZduX4Jm<I{QxX{?MBzxv_4iW~)ceIUmWoIUq{51<5Vcj5$zPJooHUmv!~
zqAPeOvut*6vQ-CgsmfJyOC$*;+{*Mtk?-83Hu@kcq)v6wV`F892*C5#obOG86&g-~
z`5U%{ii#+4cD83;hw``Shy8D>k3qOjj>dJFbTlCZ+qwWyPcm1XY<3CBU!kxkPf5By
zm6IJNty`FbeYyK9cUPJaD$Ufd{RVQm%ye4n)u%Sg|4G>#E2?|5Kw?WaDnJx#6m-k`
z-xXU&BwP4R89o&gvzsWbm6vXe)|MFm=o2}5AGIcKy1W;2lDhpVY4a~^z2vRrTv2s!
zRjcHsHM<CdhK`GTmeKZUZ^tXhLbC#w{(Remhc_y5Da8W6z4wotSm~)T?~1SX@$T{X
z+MqQW6Gf&y?mc+Exe|#=&4AdL`ue#-ub+ojX<II)3nBiQ;qjj<#7;r~Prk+uf6DzW
zCo#FjcMSMjcB@s>`hS`^{4YHqW>$8V|92l!Jr+mQ!6!#oKK2<%YB&j<4<T19rq&PC
z%@wjz7rp-Ps@j;22kh$!cD(Y|lBmha5@R8IGJwK)_E^L?(S76vw3eR#5h_hBNZ!$i
zF8=qkUZ?c$*x~zb1zhWKhu0_PyZ`8c7QUwE<S6CGWA?^75j5WI?Q>yZ2Hw~0Rr7sO
z#PSkpD2OciSFQgIZtc(vo3_-R{<m6R$Gg`d3txl(6=3uB_yCMIC>#)+^<QfJzhAY!
zk;E;E{{3j7hvq*`X*4<CUwa27fB&P_Gty{?*m!u*(R?|QfKY)w;z#YO2XKxeMhVYI
zVbUuhG|CwNcT?IBJHvKf$?ui_e>I@#6Y4VEpNISZglo2cz6XGQH-L7$-E>n$#PAPI
zX?>&&z>#qQ=726v!dSfVV37dSU0;Flc5t^Jo(D#;e_@?%t@;f^y1#W=t$4s$J0K%s
zem3a0z}C7TPJBo)HG>zn1lTbkC;~5>?sSuISCgFX^nd+WUSwLw|HA~mYTvg~g9QPI
zeV`ZV-p28`zLNo1TK33gGrg}qYlK+^0K{jdVhh=JLeLw7xhGm9{g$oa5Ti`rEbdoc
z(Oy&n3*clopEq3C;)vl7+n6i|DB}LZE+Bh#@i;dei93u$zDJZxpk)+sH??K-EK2#q
z!jm|shLDz~W?%^-;1U%J-eoTQ%h|UC!H23ofdqXVuOAbnmU43HTn$Syqe?x(#l`+}
zV8ePsk65My<#ZGw7ZH?NHXUYL_=E7G8Wc-vn)2u5Y1*e)wwZb)Of|jM$I*^y)FVlD
zlcygHM9Zcb%3&Z>+8<yYBmR8_371LYqyP{i+jN^QE?kVKzy>}dN0|^9OjSFhKeKnl
zStg(Gj(+vaf_*{S$zfO)Z;GDjvp;Q{1j1Q;VqvEgL%1^@p?~r*QaJbzVME{e>&4|g
zP)9{%t4sjvG7{aIjT2EH7P|H!O<Whh3dw*KQ7B+)jqlOk*&d(z!7QKx@Hpp2ORv^f
zekc0*ILX-5+#tbjsEYs=|7s9I?}sKM!Wv*$hZ4%NTNj}<Fv*>C|EnGW2M)-!c^IDs
zgFaddFWwMI*PZL_)17_ri5?%2UgCtUg{<%`NgP6qKdKrcS-GANJDqdcAiSbBZek`R
zlG&_{+K3+AHj?pG2oaOX-`;;04jFB3>}x`+&q@;!lVq=mS-YdZl#p#k9lo!duf@2*
zP-3uYqmll0TyO*~r(RTIH`)0hgIdu|Gp8Ub#u)dkxW}H@u!kt$fg@U0JOD`BfR;xN
zcC&8=h3FsQy+m#DQ?@IqL&p^lesk5luc9T-1N4X%^^AAbNED*GNf?k4Rk39=s_NOa
zaJ&2bA>C3o$?}o(OdSOVduwE2@76;lhpF|BXNk<J$FgW9PmHmDc*LA0(AI)%1N`+V
zGu1J_fD-7C<<=5fm8CRYHVJAChUh*+T=S(q+tA#{g;I(>_X5yIe^wc}3qA0h5<$ns
zXa1b>d%hK%lV)bc@BdSl1$u`rnjx>(Y(*BWpxvROhQQNCnS7wxN+EXbJcOPzm&KL<
zP7GYeLxR4|!oBuSw+QkZmcn!a-44L$ewqM+5!*NB<5!kfOL2D}*I_mrxG8A-h=55p
zb3Oo#-1#gS$uMkvm|TWc;WT=1Gl@jV#)j1>-)7zgsa(7s9;OHye4*^V{OZ?Jnbvg!
z`9*Vf{VXBOeeG6Edm$CR^ICj>+Q|3FjFEq!a+MUP1xK;%Yviq#@WLp*`@vqydx5j`
z5%w?>!9oba9^KX=&=q@j%CPbEtpv{xO*`K<5GojX8Cj1i&MvKT#<lM^(0F)9XuKS{
z;0#g}FO^}0QG(37RMqqCrEK~~29u+WPaIpD$y}zaN_m+6(s36gvHhjX!p?^YivTYJ
ziJ7p}cKT68@Wci5aL$zW7wZd3?M|4`_M$s=`iSa@f49pL`T<Gl5VD0JkjW&3HbbB~
zoSyv{CPavGMKl5-9MPNQsDB9_CH6GjY*1A-B@qdrGc*K8&JRT3aA1kpj+c&Q+v@fs
z<YDifP5sqv=OPKQut6I1uFmvG>gAmUoU5Knem*B`fBPeSUJiDCK4^Wv9v6N-z28D}
zey;FST5Qpu8g@Jev1Ipf96VaaYo<Rcma0g%A5Af>TiFT;#Fo`;hnAC3Y~`GE`?)<2
zSZYHDYOrwvyxS`aD}v2o!4XTu5+(^`^oL~EGSiD8VlFWmt`KqPXo9H5t-;0(to}~m
z^0ghpaL_yk7qndRQl=rG!fPu#B3ml4XY9_Ge~wwM=S-A^)hEyv*-W<suhr>;w|ONW
zqdRQJ{lj6ykNL4khXubw{)i1^L=iyqWL<x8{?gj^8=}_KI_OyQQl=||P7d9kQd=n~
zPY#>G+=?@cRznxvE%6X0@Hn}K;q`RHnpoL1fmEsuJsvaH^4eix)e~0lR8VlFt}98j
zUyCC&Bqxx?i1Lr3)88g%&TQytHzpQmMedIw6i<oPgC|;#cqktF*Jc_hjBPjwCi(tM
zRIWEybQo*J<3YLoNd6Y+xXe#aTm_LRDXv>|>TXXFc|ERjLgc?~?iiy!$4Tu8*6!~n
z?OK(KlxaJi(izxLhr>rT>=+9VZ&nc71(6lc)SV3NwqlEF54M_rA-<A7=R~bjLSl~P
z-F4jHb%jk<7A&G_P;DcE4|th@i&g+N{EzTLj$}4ccHV%c%kTk6n-mO<@b{*ptR3z>
z#*i^}EPBvoXh$^CUw4ha;Y{V$N+28KXcvE@DRjkbdncq+(N;f5q6`<fcW52;1bdAu
zs{{U0S;vq`A^V^cXv|?N>!$xiS#=<M9Iw!Si2N?qQckBousx^b4jZA`D6j^VtnueW
z49Ci|5}il}jBraoN^doosu(-08GWU|>0-0)JrD54+FAFH#t>^Ntvd#hnS(Eje*Fso
zVvTMq2mw>e`#R}`Ay>2@I`E2hQhwWIyJZU>xfr|mY3dq?tc}S5gJ&0n<8`~>D%Ede
zsLXL29>&gab6oC;(pVPi)X9YKO3om%BUzDThvlqwYs$Pi<nNcTUFL+hG|nQilSRl^
z9;t?O3!JJ<WCS5IF~V)mr_muzP%XD>wl%ORbQ*C?Cm+z(giu;*emT<OZp0VrV#1{B
z1PO==Lgsn?(fsCPy>3R82cA&Dw`t5rnX3$YN+_69loz%`tg6^vjuUm=op2|x{9Oa8
zSp$fI1#jo4wG&;aSSXp;ItE3iL<JX)ne4vZW)VhLzGuenAt3K}AX%imh<TS4h9#Kt
z*c=8@F5WK<CS-9yee?GUxXehx)i{pIOR?|f;irJ6eNQSCcXel1+P{msvP6iW*5|$%
zqYZFS>tX#1A<*M%&{b*pDg^_Hkq=8ViN?Q}QF%_8@B7!C+}eU5D$S8bl9G<*2&3aO
zN7VE2-N6A7px29w>>)Xi-q2%uwTjOj{&ouKEuGA@3)M&K$G=W2rh99^EsxAlf;0Ol
z=jQ!~LPy*bF@>>DIjK9g5Y?wRcnUOg5RE^t>Z$_DIDh4=VttOY;)I|9=nk8=(Lo>)
zu+Y)E80CXRQ7-MH04(Z^MovpOJ%J+fCm#5e?uK!hBTNzrmHWd$lP=|NXpU);F1x*x
zyn6cE{Bs3+tnE-J&dE*AmfsO4Nw$6uF9(6A3q4LratBii&YO5ip@kGr^w04J1j*8V
zaYgu;y8;)aXJuf>oX_eP$Fz_O)muyhfc2`X%5A~FloF2<IqMHlq9$vsqWeu|ksleQ
zr8hh?9)~ljx%{A5>m8d&KoEj?FTD!}Q7sK<zZk=+J&bK7beMX2{WgN(-8LD?9c(*k
zY`SC?Kta;<2Z2JhvkylBfHjj@cyT3=Q)LXw_&Yu;3U*CGt_S06c5qx3o02(pHli#+
zOJF?ZMx*wLC0bHY-e9YDRO!;q8fu5H(dVnuO%h`R(%zJ=D$q9DBSuGc#Vt^EMSciX
zx~X#Zxyg=E*0np1G%P6!&Qn4+L9o}pMuWouGbt%HY7JuyNc5ZC<O+MEos?@zJrfbc
zqfW(ONfZ{08A`&=61^rbn4V(umKd8iK9PmC3Cln+r*&rrT@5cDr&e1d<&IJg@1SZ|
zY&_Is!;yQHUwnUhA~&!WdErA`huFJiDO?~!tx4VV=un(Q@S%IXWQ?pbiG!pd6Yd8_
znHrgD-)b$X@)zO|&R#;S{Y+;0au3eXTsoz7F#Vl~hNJPA${B8t_wOCzkLCc8#Qu(i
zBxlW~CAW_Rc^?hT8$(cKoyw-QU8?VQdE&?U5}3o%1c-juUc9N4=S|H4&!ovL3lkva
z;a%`jqsl@z!Lt$i;K?{mYE`!3tkR!bMs@J~GND~hj!q^CQp@}W6!@+5)5N1C-0EtJ
zoqT1F`zU^;dV_1%?~;i<J8jHq_ObOe^7(l>;|pkxFO#nYcAaQ7Z+hd2@Fs$tD<c8|
z=TZ~F-^Hu9!e*lOJ~aA_Kwjk-)A;Kz35*tQ4A^pX%4PP(cTTg#`h}W=GtIYovV4-Q
z$w~Xh@zJ=Z+Yd)suZ?8msBv#b(da&j<b4Ovg5|M7j%O8UI{5={GSJqwk&>nnG4+ZR
z&RUey>I~X*f^iG(L@fuLKW4CwOPmhN^2cGE(`6YM=J<_#DSEZGlPp1sjJz8x#bhsC
z7?Ie(Kl-la%<t>!=SAGc`<H7EHhr)Q#F3^%>z~KnRyeZqK(1nyLj+BW`w<>e@HMx6
zKll<nZ80w>6BF4vh4Ajq2XM(g)`n^Wf7JKqIh7F571J{~r(PW*G#M8{$T+o@Z?r1Q
zZ5H7%j3%b>(P=@hpc7{3(ix#43B*|g>-iF#zAyCXh{aJqlG4-05yIE$FUGRX+a34R
zu?axQ^PaC+TpA`@D#d^rNq0cTL8-UL?-H!5I1rIPf{e0Q-4U3#Bc_Ur!_?(AqySP<
z?;1d6qL0ij6+a5du{d(p@r}(-&#M4wxo4`jiN%_{7_~})%93YJY|=iOoT>1Jv8rU0
zy<#k?R5~|XLJ?FPnJ2(DrWQ{myqHYgFE{6@N|QJ=JlhzROADa+)U3UIb!85<hr&tu
zHfAv_azUQ83%b;tE}J)O%!lgT{bi3Q?aBsVkLLk6#tnsm9GXki@2Y91T-$17V8fb2
zZ#^Z^vh$hW<GsWprA;)d%+AtTL~ag-+jKKBHOh6M`JM;@908P>8GY1o?Va0L97!XU
zV-14OC~MTH$wM6GSHzG-3~h{|$~}ZF4PUz7Vx-E-B&$OC^f}nE>RFuVJ@l*S%Y5Q;
zWZ7CdXrZ+<Fe&NsG)D6-U9Pi0EE_PDceLQ=pP~m)5YJge(jcG2+v995qVrLu)phwf
z#Zkei&GRegskeKJ)D&MJX?KpQsF&von!l#?W8jLbg{b2nq81ZABS!PqG^!q7t<I0v
zM=gq-6N{qmTwG|1qV3p2#~hm(yWr$IE4^y#xxEyodg<Tc?l!n3kb{seXpqFtVghA?
z1~ACC=r4rH<mccshp&^&)217Uv1NgG#>z+8YUC^pIJy*lm6~uJ1;JBHc;xiBAy8FH
zfw&y!^d6lux{I-wcvLC?bu517LdxP105r@3EU|q+;3`Sz3XAvE^ljU?!2}G}!uB%C
z?s+=X8s00S7-hiFVdauBn|h87a_Nc(p&WlGwgSbcOHuh0A@!_~eS<qhe=_c?xVA)=
zG=<+CapM%IEmXk^v7;(rvx6Rj8nEZ0O~wA**rLhxBSeF1ya|aHdrhq~LI~FjI=$f9
zE(VlbIB1PQXDx5`Yay4-Dd)-p3I-`noS${~h1K*ft;+;?ZNKL)(l$xwsW?A4y6J#-
z1ds#!?LVcJW+MU6iDh$MAKm3JwRiF-toRn1jOMZK0z0I{ChK5?8<**{Es~V3j$VAb
zeV<3Fqz{XUaQ4GIo!jk4Hw&B<fCzp+yF)~v0B&jMC*BuPG^gVyT%B%CrV2_lg~mx5
z6zE(de7Lbut`n%q7~m6Y>E_j%6EG5ha<MIvIpF_AEYoi;dRT}LHIqaD$;*Qo^G2xg
zujZOEdm+{Yp?;~DBwv46xWovm<eqmgq+jF-Sz#U{&h%Moy&~(8tkQ4*#kz9bRoHT1
z_Hj)QRj*_qD@sXvm@cov=g`*_JQ5L4HUT3#&RyzDS}*Aby&M#}$a?@vw*3M6_T6qL
z<lX1vEVA))c;Qk1@IGdeG*0N53g9oavTC_xy=LM5c)Kcb*IeRRRMAq*WUX!9FDK1q
zrE;6%)=dcs{4*<l&pI!WdWo@-T@$M>ue^qn5!W>Sky>TVv*F_A@P=ZzQpB<E6Kcr(
zV_Nb-7>IH?xn~&7ao1&LvA+J6+021ut<S9hu)dj9-a0D0t0alXRzJyy@$7*=!bj28
zHL@Xw2VSz+NH=Mh0a<{icMQ{rjhNfKII$2E2E;?fliw;>?B9uoD&{083@U?NAzasj
zc=R<Ic$?w8u7Y+!r=EUZ1E4qfa||e@hg}5!-Q&kXPQ=&D%h;Th#bNJY^ksC_-8?w%
zPd2kbLX72nY;<#A!UtRF^{X^?3+4;*8k>z#FKt)1t&yK7y!scLOq9F=_i&-E2R-*K
z?Q1e?`=_TQF<+Ml>`1NLh`&@uo>kc+)vw`SJr>r91*sbaVp4nC$j(xyli<SSR63Y;
zoHsLik*L6pxSnk(RbpH3Hkn(GEL(+;-}nbvK?*-y3Mp8GZekp*k<+-XNtt)@24|*S
zT@%2Nut6%H*OL6*K7*#guV5VZf}(Z;D^f_<Gq@Z;Q3n`6O;YU5)A-n@-pR6myxyb@
z_lKGtF}FP=1~Lcx<S>M@3wj@IVAP?kY~THcHtTx=8PfkKn^mxKUW}r|rwpMs7jPZH
zv*m84`~V%qJUNi?^=DsoXAOh<f(^_D$cHWio5f{7W_6WVml*^u@_|(eD*Uc?6iJa3
z_3s8No-Fn`lSM<BPqZ&XG+zk`I~N{Z?&sCl1y6yXKG6VXv&B(t9<EhmkfTs2e-byp
zy)N<km)H1ufRXwxX*@!v!OSfB7Ol~=2Q_4pRJiyV#Wd*M9;=_E$tpScSU=95u|OmA
zHa<HQjP}=}&5`@%0<Or%(-fdYy&KizAMalf$lnr;{}}htEW}Y5wdtoFUf*YXzkO^z
z9ldFnGCoBi3>^zTv_}gi!qian2q^4IkYUl(5Ts_KG(6=g(!K}3<4!4~;~@x<77Xgu
zkAs(qCDRoW2yB_3L=aQK!%RmPWE^<YQT`~L7uYU)X%N8};f<nR;xh2JUBH(CgB@FR
zkw!e=8(k|sPK-yt+E^ziNzaS??bA?NyQx$dk=uONb*wPbgQ4|*9vSs=p4x@KBFJ~B
z%*h*RjxTv-ha^Tq5@G7E2{LWFA(C5Kld=Xgy_>G5wOZYa{*lN3nQ>g|@Ca(TLOiW0
z9D6Yqa~=ntug%M&vN$}nios+DwPZ3mK+2x$LZ+$#orQTN*71|a==eSMN#2I?E`U?S
zu`p_ozeJBTQ2&#+pXr-0NGR{Fvqu8)F+>3FU99QD{lOJvHfULP_B-=^^kc#JB9t}l
zvAe%}o9SrvL7egN`g!~;(H#p&A8RvvglqoU?uJ;83Qt0^|8n^8{qiq-?0n8xB8Kr1
z|7oDrn_YmNsCY7cg!kn{_;}Z)qrv|sl79UGA_mjw`JaZ}|4S5viJkuc8+L2f{O*$a
z@b={6{{zTBA2vWl0J#)4)h7T$(&W3hsO*Xa(IMUb1%!O$wip+<84u$wd59`uC41wi
zADJ?w(IR!doe5>=`X1p(Q>Dz_ze`ehdxB6-WM_VSeioo*zF$~(rhaxGA7W{5dJfJ;
ze%$Xa$R~otxV}C^Q}A`ZpN?i8O6W%rN~rqkg+zK@ZGV`)&WgR4!-sNq@%?!9-)7!}
zYIu7(eWj7lAKyaJxm?j9NtXQ*9h%P?c7EUtYlGNNn7qHg9svPf4<6rmb$PtAIh`L?
z3;7+54y#KvXWwR&N%f$1edz=Z=(%481O^ACf^FPH>B?USOZ*t%qXDGnfUwmjf4l#J
z5lBIxI-^bsbb5YHbfximI)9#6d){3F&JIRue!D8&kvnij6Cf!DLe;0go;`g(c6vS*
zLg8<E-oI&oK00`Pz6XANj`!R5-y97<_cxpOC)*n%9v1<)GGNiGUbfHI)SLbbvX4z@
z;cRb-tRpa5J_JI!uXFb;bruZ<McnEeki&Mj=9fKUKp6id{7}VQ2uKV_c`*GkQ;R<i
z8**F~cVdw<v^roIO^#_QuPmVmkW>ov?YpwBD+9QJfH=6$m~jfKp*}-g^4M;i5J2h;
zsbB$69&7t%e6s5NhH72hKcM^fdnoTO!I0eWPr{GivL^v43A5l9uBX2thYQFV+Mz4P
z%tw4+e)B#n?Pi0vvcH3Azo8C)m_zh^55SaAyHOv>cGP;DxKHXw7w<y=6TimoJjt5%
zi^N4$B7AkW!H09oCVB4y#Sv;F{1dIDx`&DuPDE-5KQ0BWDV9W_Kr!>SO2=V#Q?(QP
z0~4G47+NO=SPHw+-;_OC5fkv(^q&L>2t!R58ixx-!8FcgzM?YAAvkyMSCJ39?aDMt
z_q=GHuk(Cae@B_+u7r%hkue}*1<U}FlIUy#x{=9dU>xcXEqBG8jw&VRyDYFu>tSbO
z#SQxIK^2FUFAAg5=lbFZmIPwIs1f1|t~xO^fFy~y{I+J=XgaVRHKY`TCF8OP!17D{
z=5wU#@v)@+jZsKMm+rKoI0r=XZ3FvdNJA)c;c2!!!IyA0BYwatKKnHE(*Cz<QRqeb
zs}J8cKl{yqJFksjwZ&k3l>r~3Z*#Ynb1Mz_A0XCNY|Ty3U#}iGVnnu(4pAI(@>`Xn
zm1-sYp6QP%MHPZVDZe+B0K8l*XSD|RLGwN8TP%YSXqERM*3x1YMluw>%Bp!*lWmdC
z&1vMT`iDf|*;1!DmG*f*rz6=T>AYs741~i+Dha^+fNTD}5)zDK8FRqE7Q!cLHjJIa
za*3YyG;RM(yv&_?^XYnU6e-XLypF5+kdQ(VIiUQdvFh^YWNJGf3dP#WM7S`(`u5`j
zBjAjs!02W`wu~+D%MZ*4e^v=B2ND`-VN`zI*^D<m02fUk(D!3}pVwGlE@al1Rbxaj
zRl2Q&%^+ISs@_AFa2yP-{k3)~7Wp|SXV0TX0Or<az6tA$JPzL5vYL<KZe0-$I-umt
z;c(sILM}?fL4>7!K-57D?-y#o6-w@f?3O8^lFSaPu7zHv4-E3Z$lUko@`34Ry`C!m
z4kz^n2YP35$;OVA`NWaC?gGSOfbj|&$?lZ{c-;J3S`=5fFA+8al6uSCta@+|1|Q%$
zY@h&=#M#8OD)0fe=m7N;`w;}rHWT@CIp&_Pd6LLz3<;=c<7|5_HVc0N6t@M_Qv-#!
z1k)D#?%dg^^+@=(><X!`zwvOcS9`D#yjX+mL4ZR<3zrdLkcI<5mO^veVO=RqL13r^
z>~aqv=IZi!zvA<;Gb4@_$wSQqIx@x4aVGgE$0ucz<S|2eI=ZB={W2Nu@B+@~g`m=t
zB*%+PjFzO6^w%kr(OkXvu6FUX^N8RpY!qNb93XftV8Sa~U0%v<7$8VOcL~#iP`vG#
zNxVCxb){*Hu>S(J4tTdbQ5I!hua%KBBH5wG;i-L4Awg6M1xLkBxyxYZp6mGP0vBT+
zdKYnO3%7hSuQYeS%K{EMPN$A1!lXCfv_6jKz;^14PB=`&Z2PGiEg7ZL)<y%BG7&5W
zo0H7e4)Re6HR#nEz0uD}#mTb5()o9$m=3QnuA-n9qE7jmFQ>)>NIIT+Vw1%xw1oI8
z)f)1aHzNe*=cAEi$S|x~{Baz$SWQexz>tHY5^sXF$+=KfyR&mbZIfqKhGdV9nS{WK
zyRi>%#g;vFPxK9S`-_NjN&399blJ%R1TvX+OJ64&cHMxZIaQysqHC%u2k2QDTHeHX
z-GytiVY#SX!?AoB+aGdJV~i@U<hty`P8%L6Bh>E&FijXXLx21U-2yEXz)OjL2O8F<
zlWX;>VaA&nX)uVsQ>U}*<*g2;yyzoHjH1GIp;r~K@6s~Y1>%-5yz~g+hsXm28WzjI
ztQDG_UpDn(%+^_P^+wZ8HtLO;e)N)6%f&xFiEA4@cz;eaT+qAI;r`hl^2(QRLFbu~
zO&D#m=isYynC}HCJKSkg=(lXS5b$mSyd54bA6xsP**Pmh`vc#}EkxmYXr^E}jAm=q
zgX>nDLL5t9%5T_1@i2E7q<h_eNfhK1{8?_VWovY{!=_02*W5XyN;FY9@YCWF7V*h|
zU6fXorIiW%Cdq97{R4-z)l>nn0f(ry0o)^Tu(^2(&arT*i5V-@M@4RG#bE+^FfHgy
zumAxiDttIag-B@kJNTMW!NcA`#%3H30nmY0oI<3W*=`v(F2GpHgp|T>cmsNlvCLt*
zmG``v7AUils~4N6v<=ybewKvTpc8*Bjq^vc4)e)}HwNkyvVw0L72eBSKc;hWzW!A6
z6ua9M+|yGqk6R$9SixXVgg}3uA(jV*?tIe4c2y+3E8xuU?j|1JKqcaH)mGfdk$DX<
zNj_ADZ`u+igDqNvlLaKpmkUYVf9{|#A|BP(Q|6z<v!p9ojN_&{;|*X(g1}*zEsTq0
zc}d&AwKNHZTXaXumxY%oYanKz@DT7uw+Z^XgUiYJrhnz`^jq<oYRhZIYfF5ZD?Ssu
zm!N4Pal|{998Ulm5gV3XE-e;$LjKOUC`Y!#ZDlOp&o|t~TQg+BQHEn7>n<9HYd=lq
zlHCB{Lo4LIABjSG`AUO)u>oI3S-ajIb|_KNN_XfmhFV@C;o8<s>K3ay6NBa8RJ-2S
z1!BkD5_f&uc+rE@%Q}v0{<}4RNHiLb%bxDh{M@kg+T|B_n`$H+o=nI!@gFWk6d1TU
z|B&fCw6k8yH4!!a$r9zANWh6&J7|wLxF+CLrA=V~Iim*)i~5BXH_#c%y4}zP8!m}t
z0Iayuxj`H~1*aQsax|@auzFw)^66_UiZ<js=RO7(Y=&7%<#;lLLlFZHP~-9vcr!1}
zM0I1K5M=>Q#<wX8MyB{&kTH)@>}toez<kzEq~w@~={3L;4YRVPG_D%`Nl^g_?$BvJ
zzaFbiTd1J(kRkt8-NzA52l7?1f<lexV=H&xYuG&25r4A>ycyA93PS|46j=8zm?TkV
zM3rX=(j8HMg1&1G!W0rC8f1lgh?e5wjHVjVz{b`Z7qPnl!&tt(LBOSm?~8jCbz&uY
znup{r{#(8H;=tkvo(dB=&cjDQdJVxG*0Amrz?jQ=`O4$jtj6R`6RN$%=<!zlnrbCr
zTZ2~%Lq%qb_O6Sxz%*R`qRf9Kq=}o0+(xc7!t#_N3uDgEb)lJf`Ml)8VsewS9CKtZ
zkEY7yqQLMX3Ufh+WTPhae^wZ$3sle#<WFpbW;Vl$Kt5TXozs1*CGU%2F3e9RS~U05
z8Vb{>gHTUaSm#!Vbs5@jFzL)aU8|57w}yj2_4`G-cMTII{ng_`o45X5G!XgmA?eq7
z37fuHJs%igEhsaySMm3(pFEvzZ|}p;Dl!zMJth;ODrRV2+QW-y3dfAbIu4SE6piBy
z9J=6UM|Vt*D6VQOJ+u#ad$h3audz_@Z`(|gHJB^iyK(KxHxu!>psz0e;~{l|xTM8S
z{=CQicNI3L6^U^L&qE+fyxam2wJlQAN-DM9@xD|$KA!7Bq!3Haz?ryNf@DBb(TXKk
zp~`<bsGZsO7Kc=^8C!T_mnJIn{c(+3%nFHXunHKCe2-nGzTQ+jdfgu|BB_5}sy%-n
zvdz4dHJG}#)7V!*UG}^A+tC*=L}vasgZz5R#6xX5Lp)#*glitvTSgTGNQjjbtUV!n
z0X0?!Pnxyi#EDox7eiXKJt1cSb-}()*iAy0OUy#e1~F#=z0tl;*h5A)b%YrGjomw*
zi>94y<}7j?Ztb_?4mA+B{sX7z0&m9t_v5m2f~l5EPJv4SXHJOm3%ds^RP+Q5x9E)s
zX^e<*N_K&(VS@cy(aGtSnY-4nzTu(TCACm`Igfp&?aLFHaXLyAoR_q4Rva&*OMV&;
z1m{2#X7_JTmv%v}ORi#AjvAD|UhVh2<3-x`H6K~9QfC#ub9i+sScM%dn9rn&QKEXB
zzEt$bpEBi}VL}4UO^xtsr<W$FhTDO}8b`NDU^p;MqoaY~h6aIFx~$>C@y*!mj())0
zAoO1?;z_#1Q9gLrA@#Iy5`@I1FLjT(Xzrj}xe{Z{adWzSMY^E0);b~PWp=jUPz<$u
zo9j12D62ITjvup@bu`-X<dcHjz0cYy4_yK0^`CRC$X&5hr%6ZZ00lKA<#Lgfr@eYt
z7$33-yb2qF>jAfgbm&xWpii-L+&b`S6vZ2te`_y*n5sw@d-8@9X0n9FQ$7H_@%OOd
zotrZ8>b$A+XPYf(f!ZOhwoL|d&&nimCE$%jfgzM#DyHuoERLEY)@*}ioX%3rLiGx{
z;*7QY!obGxaXt&V+ueLE`*i{>oH9$18>$FL(&q$DMm~9Cbq?SUWne?)tpjb}oH8Kg
zeY<x=X~PH2o^^7GZ({8VAojkUeww&SmGsZ7K5i<UKrHP~<XNE1%=%)LTqe1mgf(x)
zhy}D)%(Jp3rGGZp`zzG10L#f-m&~nsw9yP@rH3_~CpEeTE!d|rYO~AzrwQu~$f@fs
za&<{2V4dm-VvElk8QsF|v9l;QI91!N`ovr{Iy}Zzj+iRmdsifM9Cms~Fs<IrC$uU5
zwt0pd)W@SH5M<k6VLo-bE}k)+pUVH`i}<jNTZZSx)*(#6z}Z=g&vC<1w;Z413V_3I
zI<8(`=eROuxRlS@Gp-^Q<6qdVWb|rVFZ9h4J!Ki-OaWM)U#so%`$G#@Ner}mgR%_N
z)~V;CBq3VvdJf~trB=&3+0fBycK?k^sLwhSvfX7+ty3kj^csK_1^*?Sd>yr$e4Zx(
zYy(<*vmG5~e>r+qWjf#*qUK2`PtS=WX!*dST4^B1tj5_f68AY3GyBiyIyGg@H?et5
zpPV@&{<^yG;v^XJJbsXsmzGNY?KglMT-NWtUjI=TWj}++c3Z@S;}X_@>Q#81gpOTQ
zI&{1APd8D}B=)T9fHK{h@ePR=35&9_n-*Qru;MPK31i`aT?JBm0<U~B-GGj6!`H~z
zAL6P^2w>`OD??rC=!}(EYL8Tt9~cCi4rv1^MC-%s#9p_H$r-j=-*NKEw>@&h#x!hE
z%P3fB%$-Dn;on?^y){-|7L`Tv-|U6mKU3^7zBiP*p8oM{W~#M=E!0IK=K4-AZe$qZ
z@1?FLTeoomN_^wo=B<VELXTy5V{R8TDo^XI*Qi0s=UKdEL2+>@YTdgH)tFevy9dEw
zEoYw2G9|*M>!XS{1x@lGYjks$f#<LkWxZ)xau0Ra0N-tcqnemACq#Q#6H$kip#b_M
zD6B=?=B_Qx7^p@fXRVY1AW4YJ@Dd=?TZ+@E_7AvEJqhuXg%q<0_V%6Lz&=7u6%1L^
zVcM3)(`iBfLQ_1Rf|LmfmbbNN9}kpJwS!%5c@qhC>YLp!=(MyF0-Z0i)|KBfZE4q>
zEg}s#uAegJOyKx(3od7znT%k8=}grpy9ljDzVU#JtuF%;`FfDn^U&8RaXJSnvrZkh
zw*e|WAT4!=R;pPP<_QyUPG#yQ0=Fi~>L<vA!PfXLj}jF#M78_I@7ul3@52*(%7^On
z^`tEEN5jhlhHmcwJ{_08XhHnI9H7(8_MqMIp)uFIjW!s}5O)G3i5CK$G@AWd3*ctd
zT|P8v>e_v*)*U-z;bX6rNmh78;CNc6M1qJVPoc4sPoyKN;zZ;Oo>M~MQI4*EH-3Nd
z*UDvZ4ITV=fRn}DV*)jLFg<@<SUS<k+NLc!i>2+!B7*#s46n9X_44}ie#+l2Pp|3j
z_VM_-a%IT-s4ULWLFzsGDS>Y8a(F-TicQ%H9yL0_UV)d<y<7PAiOl0|__fs|Hx5Fe
z#whw6bH)incKVZ&A^)@xL6nu#gV}wd$%0;eqb7R0wFG-{va*vS>hiq=&%q0Sa}>Cs
z%9L%R-fj2xv<c*fR?w!Et)a%t=1Uw;)b;SRV0%J;jIux2JxV40Kzo72xY9${rP+PJ
zJ8y{p`Qbal<^7@iknrj&r{VkYKMmjhxAF!HGt>W@G}Wy66?y+__=XI;zZ^`J@LS}T
zqD=%3mf!|>vLyGnFQjlV0{HL*eCWFEDQ;k6a_xXy6v(CMEX{%?gG$BwN%=Qs+ItWB
zn>Cf3c<JH#x*Bs!;o<)L`l6L>J?;7V{&+;E>G^tmyngBYeB_n&*b?m^K%(vWx_vxY
z=;8jN_CC*Nv<Y7hGQ%y<`CPb3)^)vCM{D)~{{nb~yYS7tzMUE=amD`(sQ3E3gM=UW
z4Vw-TykQL7%lrO-av*aJV|@L>8!5DaemxpI-%n>>BTS`R)?FCkG4UDKcu|GEG+=;{
zfM4K5Zq58~2N1(~rp1$VP6VeyBM4pm8O6U~_8%hwKZ4+J0l)(^5Qfg_lPdY1kCmed
z+MTbx4c|8#|D%eU?ziiWM*`o^8{VJyqm-NO@9&$RkCPnU?^|DA-S4xJoFDhM^9tdf
z_%!1$O5T>&rb_syP}`h*L;!-u_p8Uj9r<>QC^kR=)W+{|!FGZWDgZWD=RLChft8G~
zQ_#4xSLv8Df&W;(Z|AhTf!ve6KGfE-<OV=cK-*g4tio<|*#Lw_BvQ+yPQ%auZO8he
zf`GeL4ik(A3!p{=@qPkqI`%ub$5JKSt?wVbPb60P--m2tW-H-gVB$Ff&oxCXf~S>r
z@?vIQ$#bBFfMNzF>5;&XdvxI0ezp2=F%2$nK<~te`U`=G#ZLp>k}1~d{$q3<qkF|B
zvtJ&?xVKWAk5;~Z&D^Nce*ug*@0!;@>iOd0<#p~!QBmaltV%Cp_i1;%cSNj|*#M)T
zf?`HUN!bQ;<QR~)YYO0o)uDq*qUAOT8@~ghThRR4Jo2hfE+i@n(IRaPv8A-d<LUt2
zM6xdUr}`XJa^R`DPB(0@JLAc4NJQ}D;f<%wMi(k>sQ|tUHx4`sJ&_4cdCDmI_azdZ
z_yhaI{2ZEK$|Gj$?@AR}xqywj5K%HXiN?W=<(qP>0b@>h*;L;^2z~vK<V_g7qfYXn
zTFkN-!A$c(Tt9A0!@@}19NO3^yXN;3`#uf=*8#{zj0HP+;xHya2ueu1<kSf=b<Jc-
z-!&v0-ScW+nTq9ujr|`s@C>}Ka7s{8dmUQZ^dOyW27*Eweq(S@ZA4^v+agL+Ug-c%
zZ`wQUa#civ2mw)Q>~JvdBX`X|3)a(}H#}6VjDIc^zm857wbe0Sn>ZgbT;3b?%o3Xv
zo^Gw4d+>~JD*j!B@sUh3@D*g>F-D>syz}W$lk=HoT!mUvme7F;^IjfFF?cNY)n%j_
z-N1lNq`fHNZa@8@owhFk6^bL7kzorzm&|KoN8GArYljcTi~}&!_BKt{abBn*U;QGK
z_tpw0;c#F?`)7)rc?c8MKs-e+LWTooO6u59g#J&M&>8=<Ils$zG0vZiy?0LoQ}OUZ
z6_tLNkJPc%3W`4?ZOH6b535^T#oXfpy1z`unlQJKX%`4Rq^m)q6MO0}@&QFRwPp?j
zMW1?pPgXJI<x5?)N-nS`yvVx5zo9E}?ij~{XOEu>bm)T!N>%KjZkNZ!s-|rj8;k9;
zvqSCa*5i?&3qrcK;M!)pA*D914^i)x$u&ipFV!+>may?&b2{f?Wd;64WLsL-`;^(Z
zrODSZ{ixIdPj&G5T$nNPS=1D~sZ6PdFf+9EeXubcSUksAEVNL`mRrT57!UsC>O)Lh
zw0CytYN4^}Xje2@!iG%+I9F}pbO!LMhjkhi+Rh*|T|$7US~hsdk_74$HzG&+$0^$h
z&(@U(J>O2u2|LC3aV{mtesgH4uv*AhF|sl;VsV?=w=wIm@owleVnNVZE}=ImE!j91
z79>N;CNX=+#5H8^@Qs_t)!Y1uxKjYWv57>W+edZo@$s*<@i5IFCaF}Seq&(j^#62r
zoImdl(;v))F_?vH`v{2tnpK`VvUI{F+xw<Fio?1QE)d5Qtk~5_ZW138AS-W$Wv{|Y
zT#h4cWJHP04aHlpd_QZ7mGrYk<Sr+GM?OBZqQl0$P?SrpHJEh=C2UAGeMvt(nMwT2
z1Ef%3bv|h>aJtfvA*vJrv#Le*$Q&d;G}G<~pSM5&pU+jCHn)E990F-$ZbpNa0-D6M
zhddlZ<Qkt<%BW`pr_c;o1~s#`1!c;xFU@mIOT~7XmQxZj9%B5toE@sDYaH>+x)-3h
z+wLqAAOp)sKhqDLBjcRJbAFnR+PLfhTTdn8%iOyz)C1GAY5v|bH-x*7Q{l9n6zHW=
zK4cUf(lGnAh4!r(hxr;?F~A!!`pMeUs(C)HN|4;Q!t2Oj<^^gyx2r(Q{y?EKl4z?K
z4z`T3X=u6@N-<%xAEm5a;V;6(emO>xang*ion{Nbi&U0p#>mN<{PS+`SEE<Ub&0HZ
zPYo;W<Q4GP?N=Ruv$9jt$$RZ~-BSE(Y+ij~VzqW7w5j%Vv>JBP4(cB+MmK1;8Ch>m
zXEV6G#mh!%lUC5-BAciBiqs#;ccwE(-|Pundc)6s{>B=C77gofaGf-~6d=s>>(fNE
zpa4;q-|kzj7!-f(y+2-4wxKwlPkLAaEu8aiNoK9>CYm@&nq5s@2_-J6!<t!i1#+Ns
zP}vbxLuvwF-Zop_pUW?btoA2>i6WAeI;t?SM9hlPoU`n=&o%gHb!N1!j!*L4pX*E)
z)se$W-J4t0#AVKgjRRtWDx0L{5n$QOFbLv{9_i0!4r#6Ca;w?E26jmv?xp>ceAzov
zu$iPnOs6Ny$@Q1kK;tjvQAwuZNYnJl##5REDi1G@+4)@v@G*hvR6ZFzc~&DAE)kF@
z#bfsi0sVw2K*}T><52o?y9ZV3lP|YyfBZC+%rYFLEX~KWjcu3w!!sX+s<Ohny%h1J
z67Fi5XfPYmg<?MtL2YqWuc<KlM26cT+$Fa7f}+CYRcVX|24k$>)pgN->y9u$s?)$<
z6^>QK#(2tNbf37s<sM`>i;QF9&>#K?5^9Cxt62dN&KZg0F;a4PO~!~R*{L!(iu73$
zT4L`qWJWSvqVIwh*2V~=%E1~yB7I81rcZ6%r<tSX-!2TM;>L$OC$Iw5l7w1~zsW7t
z1eF!3SjAuiR*t71TitTB6pZbpr-I31yv)Y~U9|G&N~KHqc0b@Y{F~--=t>)~lw(lB
zsgz_eT~CmO)Bz)o9ZGZ#aUNmc6-6LUBy|eR3na&_qsp0lZXq@c2Aq&wKdpY_%!kgn
zBXTpt)&o32Rq(HS7FE8UT0a54&A-0F!uCo|??OijCwdX9Qk=O~6|vYp{qK2x5eb=T
zj>Tvge~yp#$tLzYU>fb-x0P`$qyT>CV}d_s4C>V=gQhygd*03#`HHS%9pLRoI0a~Y
zcNf8)^dMA1(Kp176-Li1m9t$iDro3_*mXqD^__%O#iBETliJ*n#c@Y+fJv0<(^j5D
z4}XU&;F8MOzg#AK)b^$2Xac%MCIq<W>b1_}fj9@mmp<$XL5Q`CCjJj&=MW@H(4gD4
zZQHhO>$Yv%wr$(EZQHi(+qT{P`kz_7iCN61qM{;lRfx(jzdT1&85cnnE!b&gmtENT
z6({*0)nVlH7Rs_689Pwq3TAEW01OLyl6cNydYtf9w-~CGb85x_&`#BExwwz8L4Y>U
zCLDi84YmJXOp?DY-nh<Sv!%|S*FcCwgir9iy#1;xldZ$5C$rMTjs@ca>)+!ne1+`P
z1dPRFwT48bX{!fC(1zZyxJ=?=QP1O1Z1wRs3f@Cn&l*;hKRoWW%TCjJGW>H;dDXFB
z-~9<j6A2Z?3Uc?4B9m-Z3`en_%1SLTk+gOW4Hw4oJ2<!6W-DthX$^>r+@*v>n{vsl
zj7at^%A;lh<V`cd^1}=c#xK_-pbRJjIgY2f?QDPk$b9-n=q_)?e>pxCPnqCB{^&*^
zu@*OuO7jf)KbHt~Ha=R`*<F~k_LEW(FzY}5Vd2}5s2x4+<qPYuf?><tM~W%DWkIaD
zx2DmUsy>74`izGxD$1hF#4^Ov`JFn99h|ptOcZ)D18*REt`Z2u-faE>8{s~%zPeVr
zcVf?~wVrul1}l58L}a~WNivW-jdn>aX-mm%@^H^C$NOW^d-=!4v|W!6IxkUU6j>8)
z@PQH_WjfS+2AAv*IjM`a{w-Rrb@Uz@ed5)*I&-cW*R8|f8EHwzt*(N2P?=RI3yX=z
zYF|PZHit&CI^!f2CYy$4Ic6A6L=+2RE-k9`DMizi)IFHcXzYF3zpIMzQMG$NcNrTg
zM1W>SSwbOuOS;c`e668bku-_@#M1RdKTW=Ozqnvfn<Dih96urpEQSW+P{&|VqB38V
zmL)t>H_~08X6_m;rd`OU0g3Y$I(mXxMR6r&qL%GM5#vZcQO#gRxBg@Dkv45Rw)0sF
zg!e%zkUxSIgEFjt6XSl;sY%v8Ux;ClV+=C=1<vC|Ka9?%RhVF7s35cM+HW3^OhaBZ
zhUzm@KGqK_k84zy_@bZ=u6Yj5E2aZpZOPZmWt<*;-ouO2&IPCtLM>lLNCD<HfF!?{
zP2Nn6?fQVbalc%Yxp4#{Z?XiB{Ut(Rp##M}0{<(wlt&YG2=T4)a3-kI3rSWwIJ>;^
z8(3f)P6|uE*8m&Z!qsb_Jg~c>ol%Ab+8u8*fb0G@Lp-f7^dKT3F?52%TIHq0OIcT5
zxtH{ewGIzW*bRVFnPN{miC@?<E9lYQ(Vc4A0wukh_vPqAKc7jrZfY|-71WNES&ZbX
zOnJRQMT7cqINR&BWdBc}-((|*KGb@|ahYt<&}~K|;$^sC$8vUS_qhC601uIz&Dy5A
zN5O!Xql|%dOBbHoY773|QuL*z+jpOMa|f-ul*w6j>V=+#`}A0dMTDG=9tHovMAd94
z5fZvdV@qE|4@2HLoEolmSL2+%^r<kXBr4V1t+Lb8$RhWI&+21$kbWnxR3Zzy_FvKy
zIp0qbvv{deM_|*7Qb?y3BB5p{6M3M-y$giI#<?MtI9Rp}Y}_A}6YH3;Rn@z+O)E`+
zU=F0QMyag%*jrw3Q;ciySr7D<lmjP{L|6tOJ2vmL@t<z65o`xl+OU}5c3bgj&Nn&k
zBopTGD2sDarhW2YvVr$6_hsv{&I<Lnzw~72E?HP%KJGpR&1$J6ugwdU-F1S*SkE<P
zULzlAT;_5!p~`I_)IKkk<Li(GqH%d`H!EB?)6xx@6P$Mvv5QKx6{p~(6JE8OC91}U
zEz$mBL&q-HMwxc3X9st=0pL6nRb<Nm`%^-qI=0DI<Epho?g&UOoiQzvYrz~V*|HNh
z8SE^F1)%%v2-1225J4#)a7<lfiW_&SYGyF~*ea7)Pr0cRI$tvp;*oMTfizAXsfN4P
z5v(kA8$hi8lARfwm(vRehSyU`K!JPJM{1o5U}{n|kF&E%tt;9awj`4NUa1E!O^nYb
z$JfVea+*}t$t(?R2LE9a8z7cm){<(G>cbXWwxV9xm{v50JZcJc%UOvLmL;X=iKlWi
zr!T5@7v1r8n+jE=nMo2u5Zk_XSQx|mJT%hj;I-QeX%Oq9RIve?^C6DO?s`UIt;Qdq
zs|-w(>!Jn?CTI@LJ@s!yW>j)%;?L=Fy}bfIg8k!9Xk<n{VOU9);W8FAs^zx#$_YW8
zHjDbl4f}68glu8cX<kdgtZU0(Hud#MDF)AK4%vwGy9Zgrk!#iTy=QC2lG>wav3v!#
zr@APzN1y8JZ-5j1mnEx&2*MLTddq6Y1X*sM{ihXj6~|gWqB}|>2M|yfI9N{f+^P?8
z#Pge$M0Q^d76>#3B{y#IrEKJ(i~%V*C#iVH*v}}EKsIuG;<Jh*pE^|_(8zkWIjyuo
z{Mr*Tk|od3T%;A+xEH%5`<iws4rd*uU;pA&d-A|Bk!&;GiuD?WM%g{v*dJ>!ZFx`K
zk8{~_r2C32C)J_B{@M{;0W;aSGS=v08gVF%!PfQ=MvD*np9;ZkTKUl`K?Y|KX_jAk
zHy}w-md1<NwI{I~FSNQx>0Q=7u*8wRb$gRR%6SJeBPhd2xyI+Wt41Mja(Gel>gY=$
zZOc(L!tD%X%~!nFymEQ!foH<FvCB@Knv(FfvSrJab)`Yka#=0AKa1%S_gtD(%82Ol
zxgY{*R*!>vu%Oif;Co|q!wAwZfgtfnFtZPgEg#5%Gt-T_R_QL1B0wC=49XLjkHC!*
z!qWq#cQ&x)`@Ar~MD9H+2K`!g&&(oxUk6X2F4f#tH?U*|hCWr4w{N$XgH`#Zb>XF!
zo`p$dog9TTn!|Kp#+;=_zJHagC*=)hbO3N7Qkm_c%Idn4kyuhZp;~@(rUs=kp?24u
z_-eZ<7$)Cdc==mP2r0+EF=A_*<#B~INE3YNPY9%L0^)jI8Xa;4L;@OL-teAO;tW#L
z#-@A(hHH`j1=(N_Avqm($psyWBcsKMy-~t~`VBLSuL2r;Pt+W8_5?k<@qz6Sc^Fn$
z4GI`lwv?`nGv2#giDudeyY>M-c3NAF_Re{@)<QURNQQbIDr~z#F{Jz!XUHbUCPOi1
zy@aC24BEJ#&G-J-dSM2uY9C}2?Qw)p<JoVWW&*>VT9Mmaef5_$QFq3d58R=+&i$<4
zrWX`!`IQI5U&QJM{<l=pys8K?3(mWuat^rj!xAvR8l!(`P9st!cp|Ep->&hi!W*h)
z%Ea|ext4$O+|wJP*mkC7s<J)yZ!(pqnF$Y=MYr_V{ks$Bf-aAfg|uK(yMn4%MW9>B
zk=6Fv3aMS0<}#D#uh+oPRLSQODf*!(WrH0vHyTzW^IoEHywFI6PEBt@gUTb?1f*GI
zQv<9d4Ms6tp6Rcu)9kpp=L+<uMe(kp6IF{m?w`Y@!T0hH8g$3MVgWaOJeE5Mv2!9q
z81>ZMEv}~MS3YMAq_lb!L8Or@l*`VAiOznj)%zfK&4h^5f;a~v)o^!EXTq0b+4x|1
zAGH6Hsv4z!`&}zwHMd+m^IUGM+g9b`8-gMv)!Xr`wP96)s=KEam0b%^Ul#l$%ka-1
ziL)wvf63MiqRADjFI^nRV_TXRL@G!0?{r~CB%0bzmw3^D<=UYq?f7}V&fF$zxlKkL
zpOZ4dc_)lHV&!kpnx{+A%7_GU0qY$?`YmRXwY(oMm`PTQe~X^#q~ci1mlK&=ey-Jd
zzpCgm7JD`kBBJZPBmC4<foL3gXrqe}Oc+S5X>fm^ZS?#8yr58Qj--6;B_K9?Ob{5b
zFHUn{@w8Fyi08}vt^6>38r>Dw9aSVuyBuz2hKV4q3i~2hc6q;3XI)<<lDmlVk})Y=
zBI1?mhs_oQit|Ggv>*&^;QEjws4gvd*uh>8RV!L{6u%;TCSUbseU{>@nX_Ur{<ckS
zcXI5Y%nXI<1+K0nU@DM8_28N4P%k;Z(<yCVre5jipdHu~|EcPTO}5aZ$1u2GQ3wl8
z16MA+J@$XqJG;whdbPdrlrRvC)O~&550N|cAEk5YeC?m_j$TM>&<}=J<@0oXKcG8{
zb+;zz<?-}CZmxtN2qSJchZlb?&=VIPHr@pE3~r_0^A@3DI#~4I48LN(_w9f)ZoYvJ
z@3;L*Ab<R%dlCo!mw1`!|LO^0W&0nV5UnWO@dV!+J;hnDkb_iqgunzbrchk<TF@Oe
zW^O!&+`He$^y49|oU64m$>UzB%u92dSg=*uMNV1O*w|RRC%hPvJbPy@_>XdK&(GO@
z9z4R<e=H#%d3fdxy+3y!Z|JhUpRc#iFHB#r{P3>)Bst;grFy>ZuNQ;(_}`p*F5>}N
zi9#~x!I#H*e(Yae1@yj1&E#vKP2@B`9Q^x(X<@B-gCf4~_p9JsaA_FicLF#{k&Eab
z-`I`_z$M88k4L?wZs8O+W%Pbtua72pOUL#7LGp4EnYnoVvwo^UeUNkC3IhaKUk*5k
zIG~6#FoR%1Gn*Jn01Fwckvtw@d#K$g7@~OnvcWJ7w+}1jyT5t(_4eis-}n9|WZBCN
zzxPLdpV)_rK3=ECQt+Neg6LI|YnV{>4M|_$*grXTo*8zYc=6(NIrh`6w@?8gQJAue
z#Mop*k%I@=PiN!xX$LEigK)~7?9VI`9AGG9%g`Y+UYIyyB8w*%@ATT=Rb7dlJWf|*
z7;2&phuHlxyEx&6@PF83C9jtYTBieTAVXxJJzQE-TSJzKAbdn0_D&rDNeduw9zdo4
zWczAszV3}A8O!~nCIlx7anZ?;0u#l#dWn2>-H`}E<4C-F63|1i^(eLoG=hUcNEjWX
zpK5W6MF=w+A{<S5a7*Kp#GT9R>gd>IW*HJycMmU6&faNw`eo97TM>8Dmm!RNXPL<+
zvQ#80#Sg^la?n?vA7k{Cl6XM$MHMzpv?y|RZnCGFCQFD!9>&vkj>N4c7hTo_K!T`>
z#Z)0j!|0wn(;j{QEZF0CGA#r-$+qM1($W$SCt3NpslweImrRs!VNk>n93&6?71dhA
zq#m@<(u1%Z5xVXQ4KV4cDTNxuvzJ!_HepM{GXf*r(ur80O{6f9^3XhD_mmUHS6PJ}
zK$C5=J<f8($<9|>MQhN@Dp)X9Ox78P{w2_<y4vvmevF$^#(cwUBnsIoaJ0pU78{0<
z0uT;Et~516M2~i6c66&%w|lB^BxYP$*9V7^r+5;gmG!#c6f><@GM3n!apxP!kr0Cw
zoi3Wqv6F||x_ICR6mVmZA^JOUZw>=7S2;_3grT6&ROiWzG}I3TLlAuefR9H^QIj7u
z3{ss9SW#<gmy@(NB8<)@74MOw#+Shcx7er;AZ60-##GM{I5;F*eZJ&(eYzfBES7f5
zX2t(tCW)t}wG1znPRs@orQES%U}Sq>>PXk+1J$-~e;tGoNR1~|P}#;JD6E(9a#IA2
zj`j1aWtm!u6y>%kF_J2}HAA4AoYCZ_D-~XE!yvMFY!`eg3L-jv5Pq=TnISp-agq4*
z1|h@ud`gM8{3onmo72A93WZ24Yf39N#RiB1lNl-`fkOvee{Ow=9Rq}3I72tCp?FW-
zn-AgcTs`>u@Gc}q^z<6vTi6d`<H0(QaWVE*#o@SP@C}`@S-*+|`5xvVVHP@S;r<d}
z2WAdh+Qz1IEM$9)h>cYEPeS3WG;Bwcnk9{30xEWOYzX{fqfDUw-(7thW?3De6C+o%
z8miCJfNZnXqC1na5&GB>SALoPkKFmwJ@d!`zd9gGYx#JL1mjU#d7ybE$M)=H#%rw-
zM8el_CZ><6RA#58VY`>lXD@GBF!NtxB4&kU>mxbV1dZhAwsbd<PI({vB)d#BBN6#G
zm9W`WMX_fv3?bBH>>ML$Gp#by3^jY`yG)eQZ38)22qJ@FEQrth7EUU0ERxt`B1sm|
zYDwBB@ma~v#WJSr-t-(yh5}8Q=r{t<W@O@n5dT)iXocx2+2vYF^xFaBvA4qWo7+uu
zc$~vHL@cpp=y}Ll@|7vWp8iUr|EguBL?k~>^lf#(r&9a2IZwTTjJGm-VX?NqNTiMw
z6%R70i(SbG&_qc7Vio($>%^BgBIT%6P-{2~4nwZAVuoq7rs1H>_}l^<T%i+|XR52W
zk8~$?)}0cAM%Z+=83UHCh@aTQ-caMZokI_xgDeoC#Q~m!EPcOrs;V2944@iQpvN)P
zd_UpE_;zeyv)1k@&IB&o1F=ZVST<q*!s!iFxKZ*1161@82w&S=iZzjE=z3`-+Lj^W
z!hHz9j6in*pq2K}0ow@3mbHcYs}Ii7F%7E(C#Xvu3dD&5Nm1=cb?l+*-Wp1I7fYP6
zJN4fKpISSXV@L{)IfW=WRJ1CvTNDbH-;H)l4AR(Z69K}ai3zfQx`0oXUb+=&pA69N
z-^p=(oPb}QbSkm?a3=>j0J!3W6^@8u`#sb-!%bMpbcR~BsjHAG?g#$TUR8nkRTozj
z7gx~`4Z4aHv!H2kBPqt0mqKuV{`&wAEQ|r7EQYH+zXgkhk)m+t-c=?(@W;^_*CnG>
zQ+g=tHf{`@nPK5%V|@$9t^?kzIsJSz9ns*))^Le?Rqu)Az^|cN22N2ubI%#FU;$H>
z-HBO80msVKr*!W?3pV^U6f5UHV+e<piJ7g0Y!VORAcGjDF+<Qdr5208wnZ)nqULd>
z{LO|Qq=TYaL5LCKF+@9<gIcP#V-YOK&0SODpfJ$2=udMy<n2on+8eN^#}J~wJ`x>p
zs-3R*l(BH$8!E$QR?&&m!czJxSw-i6Y^DGdnYpa#(#gy@7=B>W*@!*m_@mVDCvwPg
z%-()iQ)0+Nc|9`JOb-stH1%32NxbPBfRp9zVJwEngjL<BJtRejLq(3bj?4tyvN=kp
zW}70`n&ZVsB`L^rA}_dnte{_zDpJ_OVEN<~!paL|>JizUNgiOvCiIvSe4KHVkWdv6
zQm0MEGjy(NS4pIrvM{=mzmP4_A}G~ZW8CO`<S`9x66<dlln`4DWL!QPKgRfQc`HMU
zO4Re;$WfrsuNEp-61i5yj1wG_E;%Kfz;=TkLG;=?XRCJ5D5{yQ$p9BLq&la1=nawm
ziy03v%i&F@=(bVZ0}WU!4DeN`SvJX%A0-3FY8?%zEl}G6td5e)K6J&~>Ul1qAZB8d
zpyO#mGgbj+rF<{0*{fWoJLthkJB}p8^~!+pn}|&@yXC&6<)u<=8fEYp)Cum31p@PH
zK=|`SV#H<%xDRcN^4{wP-ECi)-27(v!zQ!uu?k2*x*sJOjAZTlhPahoJ$sgpKN016
zv95kQ!a5a#;$F`JNvy4t$Gob@`d={Ym4$>Ag)1PIY4(jSiux|>o?fiRrNHHdQJo7k
zAcdLrhGMvsk_$AdPu^h69EQE*NhFukl2fi`6et-jk(H+~J5x5ESA&ZH1B_V>l=ri=
zt};MO0&}7onu??-PNrqr)nH<d8_VY=I#&!>#JbN+Jv7rLY{wcDOpIc<3`^N01a}3{
zE0Tk4Gi?myf(-drC4=*wb}!(~UW>La+G9lqepz4iBm&XV7RKi~05J6n3+}n^ejkJF
z$fHm$SgpWD-3bV?)G+IL-yih+y<RWRSvNmVy?$>WY53nadW)U2d3=7RL-04h|3~Cr
zW7Xs&w<|!LCuTW2U!8F#c)1V`uKUWjwq<rvIDzZH=QlDWG@=`v!9w-G*7Kj#Qt##u
zdEbW1i&=;>{sLG+_Sy=P1pSMRHZYIW&V^je<nF>T<HQ5Ff49^Mp|+(8t?Vp!upS^Q
zZ)2A}Q%7Q!yyxfXP6C8a1|7N>o+DFHsEzXox^{V{_WTv9)$WO<^pJ#8H%C-1#aCmX
z5mADsw}>=t20F<Y7b@B|=-s~{#3Y8wiFamFlV^g)Iqiwrme_URTlwBYLWjF=4Bq6G
zFWxrp@L1{H9-;+Q0mL}r>)qN6Vj0X@2Ym?~%N|J>jVZSU-D$d_q!@X^z6)wA4KxAq
z=W7HC*P&8$+d#tz!Rl&WbKnLmGpWpG4vjvb-O1hd{Z**Zb$JA9YPk4r`bW(RB1bpl
zlQfO9?D4j{*^H~SBycP=rj5AoQ%7j6ZrPN|-Vpzts9pyWC(KbBTHwjG6ik10(5OO(
zwhk^Bf0aUtyT;PelB2Dadhc#t52^0h`3xm?82nZ2gi$BoE-$6ICQw*WVi%hsI|!{_
zs46pWpn}DmP}f6bh7?S;Mm48Bp8rl3P+enR`rUV#3Ot-1B*-I#*r$Tgg&yqDD;_tH
z+X`chPZMGv*S;r^DmiBf-m5m}lFP*|O$vcSU0w3fQoycBr(b3>R@=u$<F@W|47e4-
zYW@L!H)iTwSf3u%?i)nEom6!n`j>;zgFE2*?$RZ4yhS-T%&qpc8h6>Sxy~Z2y@$+U
zQ1hk*Ms3_cX*C5$cQd*>u0~V-qV?I3HP>jEUrT94px;dPqH{ErEw06KwGTy%$Wu!x
zsx@KKtQV=+kGhN^TqO;@Ijn~WRUl_Jp+nEH2OpPLTV(frhi2y<lQZ9%9$Mohwz7TC
z+i$jp*5+jDFYZ8)PJ&e5fQHg=Wxb}i-$%4)=2krAxNCG)M@vy^t7sED%?SEDyo36o
z%60(p4cy#z0UDofHD|N*#tGOMwLS3lPS(jQ%P;4}Lyo0sE2|8tpW<LWmjPk^avFhj
zbH%DGMK%1^JDBN+p^V<DmZ#gnxQgy1p|N|0g(rUmCuU#$Gr~2Jt*0ROwM;b1`Y`E^
zjxl4!>8Y#%+_gtZP^Ey-e8r2-;?~N}vnqc*l1Z<;kDP;Ne~h~S4JV5bU^oISLU6-T
zcSW=yMtng#jO63B9o6Rn356PDUcG<w#@h05ec}!6^`UzJ1POzqj#|s~3FkR;=ndcl
z5O`P=!d1pJFQBltPk__ddOY@D%P?wIvvz%HwXK_oegEN{VoO;tJ9Z(UQ(5V^s+saO
zXHI(2NXkI~Rsw)4kyfFXVV&F(uok4YiPLVBohS#V`3n$B-IF>ZbOj8!1UrdqfL3e&
zO=kNVPdP^(F*BK<mC}U3P<m34rQlj<@}QBe)k}HyMu7AXlRl>FlDD^0W}I;E`h2kn
zYfF;{Ka&^Ph_^_2lA1_A4$WqjAN0<SDJrpsqv5IgJGIix0;cCG(f$SYmrCchxMQ;P
zV<hLhCVsprS*Wo}{<`H-r3NNXa4B;PeYMmJ)Zd9(wo8>7YI^sok3kv-wxX%~odhd#
z{o2%98gO8QL|9(dJ*Z02s&0$HBo*?9b~u?%Ln%`)j#*A;A-{>E1+vsV@Rvd8taRdU
zDQpAQZVkPup*?7crQ<#nk4;1_;6K|cttq-Yld#<=I|~c8u^X7~a}H?6D^obYuw1on
z^Soc%`ElU|q2_6s9T=96_N9n~WO+6V3e6XBEF8(62CZ?zV*p6&yhYCE?wr;h_WHbQ
zfydCfwHsF=lH70rc0syQmN)Ls2cnLq6*n5YiHRWxj<Td|7g=;|jheM-q1uX};1AX4
zI+znpc?{2g2{lbwW1UGKC8tAcvI}<dP=0=E<d)SD@rBN1Eni!YEw0&~zF<Juk@XK-
z?s(VGl%tJSS%O8ReCXTl;v6H!2@e`mHsdc<slbq<P8YRZ;ttA7{c=y;dosP|&xh7g
zvL#dswU*@Y_p0cc0qfrmsj}HZw*r)m@^qYwaCmbX^l@itzb1sw&a;ykkf`2QDOvAM
zQ5SALFHIt?VnR9BSFyUqmVQ*QGLXyC_{(s@kC7LCUIC;8$R)!TeG^l(scqd(RWBf>
zA4*tl|8=jMZLVVMej_P#uT#cJ)PU}C)ZD|CS%NT(zlpAk2piZCxd)tXj>#(!D0JAO
zhi^^BCrP^DJNu`h5K`2T+^wvz=h~W<H@5KS)=>WDnKS&+ITzH!1TA`=(ik<1I6$qp
zt+EIl>lY@${lK&##h?zN>tn)$w|2GxLV$trXJQgZ4-Nm4+Goe0l|9?{sn^F@ZJ<JH
zs+5JU)W;Hlir==hjG{R!PVh(4pHjY}jJZ#z?Gx$ryW4e`%p(`y!eGsOOz_~UVoqRj
z!H5ii63u5H7v-xi7}ZO2l(N6SZ_B_P5if-U)b!fgy1u*QCu5r4U*FE(7ww#hq%Y+8
zc|nE-d*Rs)_cBB{ws?Ma`4}#`^ha&iP(~Q0e>mm!n}%Z+vyPabiMK}BdcNeP7F&PP
zF~5J1XcwFQw_xc1Xw_h4W%-}MP#iA%e+ZZJapORx=R#<b0tf_?%u%3*1mjR^U355`
z5_PT(Ghn|0*+`$7ZR3XppApS*CISz+S<1xaE|jXCcPR37{r?;SOU^p;a=+h=yQK4S
zf4;8E$g>}N{l0wO!OQe~y*(eia(zGZ$bGJhau6cQ^m_c>_s{flzccw<<}uktt%RCl
z74g5%+!kk{-)NAvYy|lMYz)5htf2M$e#ah=C!Za{%e!CGA<58yjgMlK#=U>l&SmT|
zj-37qWcj*50esngK4;5L;wt_`nf`a}P!nEkA+J-e&sg9`A7qwotR26f<8dnaEYuYw
z#~i<q-8{*XW{yON>=i*e^0#$J2ExR1;Z(J1_wC{N@jTs%|9v|Rve@aS=l4*M|BJXp
zX)^oMS`-1|Z%v+#pa1$ufD!#G`SjZxltgg{5_0qCdti@;6$gUa{{+$9$ukzE_m?>V
z7eTkNg_oT32NhXmWt6jQS^4er8T^@^-Sur#VO3RzC6(pp&l@@a3p!A>bGbEZ9uF|4
zgFp8P%eJElaC{E@8Y*WKj!ZCg(HZb4P?;&7;kSrMzme5^>JMZr+|7JF=+VcexW|QW
zZ<{3x0=<WAine4byx`dcmd>zuY`liHFKgV7utFq}n<YXJ?w|`{-h~~mZw(Nbeg-a`
zXdv5!Hm9SfXhDmts8xj$txjO&_Lwb6&T)iBG6N;TFvWEy<OW`i@hIdg{)2-7A)xDs
z>&@wgP*`3_kIQ3YpmKKLjLJMQ=1XEc#vQxXh(CYotDH;gu9=Gh+Bg3?13$Z)jTaB=
z?`To<_iWaMork)%=l*0n$YT_z%;Tkwn~hP5-amV@5w#Amf#kI^D_uCKUujD>5EXMq
z00L&KIjY$f2@giPylZ~|53vtHDs6aRaKwNoi>3o{&P64EvUdJ~t1{E(A1p_})|9!s
zcq2^c674w7^00}P=E<#Nt_upl+zNYWp={K3*GYu~aDTNcuJC)`@>Ris>R7$3X!wdd
zS|P8eST~vm!31T;+VFu%etAgL&b6MPijoh&K}@&_7W0^#5D%7`deiWq8jkJv8=x<@
z@&ku$?{=c7(1gGEYvti%`N)pE+$p$CCV1|dAVENV+%$$nz=r(?#59JkVugLNjj=_D
z00=+f*PLuaAO_+;+3aIL3HS!JUJD<=beRE|w#^#!3(SMtX>Mrfv<C;eYTou-MCZDM
zOd@C=)*Cs-<-3ge(^H)XiYg4;k-${Bz+YLOcY-R)U#E*k0{-A`8I1^L5`R4nSKn#0
z#JtGar8ah4r$HXAan`b<<@>)AoP_{uKh2*~X7f{Zj=XEf>$p5@Opns&$ER_f&9jMH
zN9~DEqFoLgAK*+=E-=pxqt}jt_uP$s@!yUZs$T1so3V{aph+R1;olsMF@#v+1jH}W
zP{#haY&e!bk71J)WLafcCGFX~%eO}jMoIuA+FS*4L0^Y{KW`_kcDr3a*LJ@h-Cpm{
z@1JkBZXXX{4?_RiUD=x**^Sq%GzCk}N_?O>JBxpt@Ehp?<_=77=1jqg&W}~IzHjvm
z3m%bn9h<rQrc0S=$DiYt+X$K&NYIFB*vIdp%HH?YwE4yQn1kWF=9JW>Gj%`O@_UV|
z1uBG!i5kdXfE}O;51|B3_3IG-rhUW8XBY+U53iFJy)3V5NDup!I1Dv47=Z!|kCoTk
zOwr*R3zZ^w{ZII8o@S7Rti~d6IoZ?-7eG18K!0?=SP0Q}%5|PgG=vE;Tj*@5yms3M
zRxU0b@5T;8a@YX`>n>H>`Gc#7Y7mP62Z_aeoN8uoZx2I9d7AVCg}8zEM{Wf=+{r9c
zN1qWK>$4Ak1F#jGmJX1W_qQ<o??e3BOiFfxNxYz!>%#PVz};xIiuQ<EUMST7D9Z?b
zTSDT*dPRF9)7%_eTx!e+8GWv|lM$NXl4$Vs$VoES^+;+16C(#6_0C+GmPRc$tQ$~5
z90rk5F(JH*$B?zbs<fH>KjEK*%;AgCr2=`Sl3nMu=rQ+d+FIPO@cOXqn?|tk#x7@_
z_ju~C^fV$(n0T^<U4*O<4fO+u2i`}t6&&-HRTVD&iP?l>@XcyL=2Oz%>)%wkM28pS
zjR3Dz#T=s`-H1L~eR?p@<wlenW1-zs-xIp-Pu6YBp2+h9E&Dq+^weE9_v5TMCv|2?
zqZYyV#$G1M#v(?%f^a(O*&Ay34iEq!RqaYPDif)KPP4<<=+?f6)YEMT(veQ1K1yIS
zTC@4+C8qJp;HBlNqDv;iDAgN^>QzGLj_z%h4hS;JUqcQg3e)5cXQgW(v_T2_*D4YW
z|00~2=%QqH@kLsF4`&eb%Z{&X;PedIEXmnw)B>9fsmL`%!4mKKkBxC4+(>g%2u7Gn
zr0r~6ckP^>O|Mx*@@@Hh`NLl~%I1T{cCw4zs@`1Lnr75Sj2An2rIQpNFK;4ea)JC@
z)}zVXkvz-mhdjlzcc%>4T#Z4&rjuN!i0csQj}R!{vO<CTCR+rNx%=Ys>rxBVk$DKR
zh!^a3)AkGMtJLr`0jNQNqjMl<H2nSoK6|vIq!yKTw9IDS%|k#<NCaYXv;9_=boj0q
zt`~FDHd!~mDDqnH3`O#)<h`aWw)t7X1^QAZ9b5n)D6`9+*MW1kvTc7(2MgqEsYfi)
z=&tM?>5X{?#=Ff8^OC$MFQddoXjmJ-kpiTzZ1ssoWHVH#(*dT9#R(#)e+f%@lu@=-
zqC={yvjLkP<J7D8j+kqYJ1>+`{*Na#2)$}|Ach#$sw?P`QR)?Ajr9my#D^8BYwpGC
z7hX$}M(bF02Eyjso?Ynm;28aQPo9%oCL$va#P^rck68NXFC6;8*DzW0&*H*N@&W#M
z5~k@!U|McZSbgWZL&O9bFSM6I#&pI$cVJ^egq;K#(A#`NpXzK4qwney@6)g5E6aGB
zMx^KLi$#S6YIQtI7i_H#dv^mX7Nzra635-)ys2TJEC)F^MdFo;ipwy~E)8d8u(cd9
z5@RAHzw-hX(~d}Ux5n{u`0@BGcm|eJh(>3Q>TF3lUaQCgUjOidT@7ufq)_7DHB#63
zCA34lK=Kn=|2_<Omd}|6QVk0)#}(Ei#m*C5&=GrE7O-v<m|-V*A_#?m{&o9npOJ0Z
zUTNv_SG<jzwc#iqWYEl+*lV_`p1sCOAgoe`bS)2AAAQG`R835d;~WCH4mJEBjKDoS
zC@&F)aI925CK74N$o7OG#W3ETs5MZpF7#$VFYmtfMjUXgQ6N;WYT0Dwjs?f|+CwwH
zAIbXD6nA9n3DvcqLWLKkDIF3vj);yh-R(y7?S;O?M3AF}53jItNhB#k3GqI$sF}5c
z6>X6hWrXtS!9TGA;@;tvDAN}tlX^-*%*wN82SRpNDY~vX(}9)eX>d#aoulPxu`4>>
z$cF&pwg+w^LPl_XA>j?c_B=R?TWn;I!nai=6jp{LWBVj{_Wm?jZi=#)-U1yPg@lsc
zV(U2dYBQQz&NPXThAMr)hwlVpLVfn;O`^Ps6G)sr`PZZ{97|UE)gNFAG74sk!Ve(p
zSpunS&l!OCi9`o2B$Yo4KAA0YkP-rmBl~!(hl{{n0g<Ueg?f2Ch(V4>s~^f;>5(@%
z$wQDy7OglAtYg!^H@@XvXeqUt&%5R2-yf8K&0%a;@_jelrRF(_z$gP!@Low}3cF%>
zj#0E2;@{W!?sFShP$Wnn((h2bx>D*wE!g|ozIMe(;tfPt%1>WTG=`dn#GiHH2zyyz
z&~WdcI{jS=Nmk&rU6I3#)Fl)P47#B^KoZd<xe^cXb`-#(nzLRuFp{-gLi$~LsG1{6
zQ<yIF#vjrsJq)&7DOu&5&Bz7#09TIIgrd6y3UD?K1`UhB7-gsMG`BQgy3Q#6JnQn{
zY3R<#xQS*!pUw$$&XC=yJ3yx{G}UOVjIDY@Ll!~eq=vFg={b$!(#O{Ul@)Z>(ZMPu
zHD(OZFt~Yt9b<K);lvnt%HaG<ij_osCagks)k$_2+M7E~2)#V9ETE$NONYZz6>7iU
zkblb9H0I8U1<mUqj;JwsW1ZBDoD)<-8=Fkt2i0RtDxX-z3lJ@Bk(=$ogcP>fb9jKM
z6vs#CMR>raD%8?VBsT;nh5fk7lldgt8kI-%ygB=+D4bl5uL3_siDcm9v21KZzH0Q8
zWuD4i0*aPT_F5BbM`~JQp4$YkmL%MTd(;|74DRe1;tBtXJ{Fd9RyzB$6r`4G088MF
ziM6P7E+j(%+POHl=@D%1i4|v@dGBwzIoE><*Pd1@S4Ykr+OZ@bL#z7t3ih@dDjsa=
znK@Ryu$1G5RC+n)TU8leK3uKAcl7PUu2<n$wS%ykti(Eq?bhs80nU3Y;zI9cTH&O`
zTxiXV%m8kXNIs_xZmEZE9!GGk3D)}k8j|lS1!7bVx#O{@HLw+84iJ4fDby3Jzp*qZ
zsz-=?!f!6B$)BR5ISbSpMErOruyrQ;ZLU*8zgU#nl^NYhVH7#r8%u&FgD#J;{?e{I
z!JLC*Dq||939IdSNu}@##N?tjW~8vrfYw=)1b*|NxNA=~jBrng;nfCsID=?vwN!pw
zCqJG~+pHT9m6>2RmVkPK%cG=pGHSKG_uX3JQZ${Ws!w-Md&+l)QRud=Y5PB!YB)tB
zLe-3G)qOn)<vZf6Tzz*IqN228;&kv$B&zi&<(4a^9{)i9dtKN36n)vCLd0*{hPPE#
zIvUnWctK4f8X2cY%WR0JN>VGN1f|~L8Z0mP{`CdH5kTAkAq0)=2#ti+zjzKcRmr7{
zn{<MkBj3>*Cq2i`-fFh=h_Y>RBgKt`=Fg>k;kh_F&DgS(2Y0M2zYG(#*dWl?;ou>W
zAKHiaxYE*~T8}TT`A+yRur}qxgq;Ozs3gcyla8dHOU8-N=D3As!>^$><5Wk%JQu2v
zinqcZ6-&Rg1gQTp+9(5_J_+J*W)fw?z<sH3>Vmi#j|s2a?be=#EEjh@IS>+Nou^|m
zbxbd^ELbkjqA$>?MKE~UjC147Pc0STANZ$<idO`tAf||aqE26R!i~+qhv2`G!?+ty
z=#AwMY!a}c@w%!(tW5dYiQ^;O#3?B5u2+}Q%qGG%-i<A%#s}SL6TeDL=>$nh4(u1-
zc|b#S?&u6pFw{v~_Mu600)D%%GjUf)VPG2~*hUnDB-r#yO!xCL5y)xPcsIlsmL^z5
zXxzGUOvqW)^Up|3*}I||94Rc>{^;em;TEnr!r?Vc=Lr(I^<GV$B3ky*&qobV)UV%&
zQQyg(*U_+In~Y3VdCp)bt);)IMEY^u)5pk`JZr0F4uV`=h4ba%rTo}1a?py|+d2Ju
z_$mrjVkX_I2Nr>zA&Gr=3&-jua={84^e1Prl081=1s(&fkr}Xw;8fvzStD>+YWNLh
zUp^DI;ziRNnz>XUWh!*Q)4{qA{9nz-rfd7#Ed4_n{>>j@O_fF0g&gnjf&-d<svtO1
zVXdzwo0z%SbcCC8e>{22bikXwJjk~(j}%K#3;8B-R!`h$U5=`(FvO(-dAFo3+UlHX
znr+zzBFomgujWoyvRFjLNWyFNC@hQRx&4cTp%0AitLUWl9*T9rbjx)1-Q-e^WPV??
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%0DxjY#%pz_?pRnxgq
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%0A}p}P9>I9?TqT?&H*Y@|eT+i<
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%0Aw-8SbUWoN&%oVKPR)I
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
a`Mcisg|9%Jq{_=HAOG>6_F2F3mH!88P+Tzp

literal 0
HcmV?d00001


From 45c84669f28c4dab14f66095a370af9fcfc73d63 Mon Sep 17 00:00:00 2001
From: FabienCoutant <your.primary.email@example.com>
Date: Wed, 4 Nov 2026 16:46:56 +0400
Subject: [PATCH 38/38] chore(release): set version to 3.2.2

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 66a0c9c..86edcec 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "parallel-parallelizer",
-  "version": "3.2.1",
+  "version": "3.2.2",
   "description": "",
   "type": "module",
   "scripts": {